{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " # Feature Store Tour - Python API\n",
    " \n",
    "This notebook contains a tour/reference for the feature store Python API on hopsworks. The notebook is meant to be run from feature store demo projects on Hopsworks. We will go over best practices for using the API as well as common pitfalls.\n",
    " \n",
    "The notebook is designed to be used in combination with the Feature Store Tour on Hopsworks, it assumes that you have run the following feature engineering job: [job](https://github.com/logicalclocks/hops-examples/tree/master/featurestore_tour) (**the job is added automatically when you start the feature store tour in Hopsworks. You can run the job by going to the 'Jobs' tab to the left in the Hopsworks project home page**). \n",
    "\n",
    "Which will produce the following model of feature groups in your project's feature store:\n",
    "\n",
    "![Feature Store Model](./images/model.png \"Feature Store Model\")\n",
    "\n",
    "In this notebook we will run queries over this feature store model. We will also create new feature groups and training datasets.\n",
    "\n",
    "We will go from (1) features to (2) training datasets to (3) A trained model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Feature Store 101\n",
    "\n",
    "The simplest way to think about the feature store is as a central place to store curated /features/ within an organization. A feature is a measurable property of some phenomenon. It could be for example an image-pixel, a word from a piece of text, the age of a person, a coordinate emitted from a sensor, or an aggregate value like the average number of purchases within the last hour.\n",
    "\n",
    "A feature store is a data management layer for machine learning that can optimize the machine learning workflow and provide an interface between data engineering and data science.\n",
    "\n",
    "![Feature Store Overview](./images/overview.png \"Feature Store Overview\")\n",
    "\n",
    "A feature store is not a pure storage service, it goes hand-in-hand with feature computation. Feature engineering is the process of transforming raw data into a format that is compatible and understandable for predictive models.\n",
    "\n",
    "There are two interfaces to the feature store:\n",
    "\n",
    "- Writing to the feature store, at the end of the feature engineering pipeline the features are written to the feature store, e.g:\n",
    "```python\n",
    "raw_data = spark.read.format(\"csv\").load(filename)\n",
    "polynomial_features = raw_data.map(lambda x: x^2)\n",
    "from hops import featurestore\n",
    "featurestore.insert_into_featuregroup(polynomial_features, \"polynomial_features\")\n",
    "```\n",
    "- Reading from the feature store, to train a model on a set of features, the features can be read from the feature store, e.g:\n",
    "```python\n",
    "from hops import featurestore\n",
    "features_df = featurestore.get_features([\"team_budget\", \"average_attendance\", \"average_player_age\"])\n",
    "```\n",
    "\n",
    "As a data engineer/data scientist, you can think of the feature store as a middle-layer. Once you have computed a set of features, instead of writing them locally to a csv file, insert them in the feature store so that the features can get documented/versioned, backfilled, **and so that your colleagues can re-use your features!** \n",
    "\n",
    "In this notebook we will take a look at interacting with the Feature Store through the Python SDK,there is also a Scala SDK available if you prefer that."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Imports"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The hops library is automatically installed in all Hopsworks-projects. This library has a module called `featurestore` that provides an API for the feature store. You can find API documentation [here](http://hops-py.logicalclocks.com/)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Starting Spark application\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table>\n",
       "<tr><th>ID</th><th>YARN Application ID</th><th>Kind</th><th>State</th><th>Spark UI</th><th>Driver log</th><th>Current session?</th></tr><tr><td>42</td><td>application_1573462172517_0010</td><td>pyspark</td><td>idle</td><td><a target=\"_blank\" href=\"http://ip-172-31-22-2.eu-north-1.compute.internal:8088/proxy/application_1573462172517_0010/\">Link</a></td><td><a target=\"_blank\" href=\"http://ip-172-31-22-2.eu-north-1.compute.internal:8042/node/containerlogs/container_e03_1573462172517_0010_01_000001/demo_featurestore_admin000__meb10000\">Link</a></td><td>✔</td></tr></table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SparkSession available as 'spark'.\n"
     ]
    }
   ],
   "source": [
    "from hops import featurestore"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%local\n",
    "%matplotlib inline\n",
    "from hops import featurestore"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Get The Name of The Project's Feature Store\n",
    "\n",
    "Each project with the feature store service enabled automatically gets its own feature store created. This feature store is only accessible within the project unless you decide to share it with other projects. The name of the feature store is `<project_name>_featurestore`, and you can get the name with the API method `project_featurestore()`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'demo_featurestore_admin000_featurestore'"
     ]
    }
   ],
   "source": [
    "featurestore.project_featurestore()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Get a List of All Feature Stores Accessible in the Current Project \n",
    "\n",
    "Feature Stores can be shared across projects in a multi-tenant manner, just like any Hopsworks-dataset can. You can read more about sharing datasets at [hops.io](hops.io), but in essence to share a dataset you just have to right click on it in your project. The feature groups in the feature store are located in a dataset called `<project_name>_featurestore.db` in your project.\n",
    "\n",
    "![Share Feature Store](./images/share_featurestore.png \"Share Feature Store\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['demo_featurestore_admin000_featurestore']"
     ]
    }
   ],
   "source": [
    "featurestore.get_project_featurestores()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Querying The Feature Store\n",
    "\n",
    "The feature store can be queried programmatically and with raw SQL. When you query the feature store programmatically, the library will infer how to fetch the different features using a **query planner**. \n",
    "\n",
    "![Feature Store Query Planner](./images/query_optimizer.png \"Feature Store Query Planner\")\n",
    "\n",
    "When interacting with the feature store it is sufficient to be familiar with three concepts:\n",
    "\n",
    "- The **feature**, this refer to an individual versioned and documented feature in the feature store, e.g the age of a person.\n",
    "- The **feature group**, this refer to a documented and versioned group of features stored as a Hive table that is linked to a specific Spark/Numpy/Pandas job that takes in raw data and outputs the computed features.\n",
    "- The **training dataset**, this refer to a versioned and managed dataset of features, stored in HopsFS as tfrecords, .csv, .tsv, or parquet.\n",
    "\n",
    "A feature group contains a group of features and a training dataset contains a set of features, potentially from many different feature groups.\n",
    "\n",
    "![Feature Store Concepts](./images/concepts.png \"Feature Store Contents\")\n",
    "\n",
    "When you query the feature store you will always get back the results in a spark dataframe. This is for scalability reasons. If the dataset is small and you want to work with it in memory you can convert it into a pandas dataframe or a numpy matrix using one line of code as we will demonstrate later on in this notebook."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fetch an Individual Feature\n",
    "\n",
    "When retrieving a single feature from the featurestore, the hops-util-py library will infer in which feature group the feature belongs to by querying the metastore, but you can also explicitly specify which featuregroup and version to query. \n",
    "\n",
    "If there are multiple features of the same name in the featurestore, it is required to specify enough information to uniquely identify the feature (e.g specify feature group and version). If no featurestore is provided it will default to the project's featurestore.\n",
    "\n",
    "To read an individual feature, use the method `get_feature(feature_name)`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Without specifying the feature store, feature group and version, the library will infer it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "Logical query plan for getting 1 feature from the featurestore created successfully\n",
      "SQL string for the query created successfully\n",
      "Running sql: SELECT team_budget FROM teams_features_1 against offline feature store\n",
      "+-----------+\n",
      "|team_budget|\n",
      "+-----------+\n",
      "|  12957.076|\n",
      "|  2403.3704|\n",
      "|  3390.3755|\n",
      "|  13547.429|\n",
      "|   9678.333|\n",
      "+-----------+\n",
      "only showing top 5 rows"
     ]
    }
   ],
   "source": [
    "featurestore.get_feature(\"team_budget\").show(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also explicitly specify the feature store, feature group, the version, and the return format:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "Logical query plan for getting 1 feature from the featurestore created successfully\n",
      "SQL string for the query created successfully\n",
      "Running sql: SELECT team_budget FROM teams_features_1 against offline feature store\n",
      "+-----------+\n",
      "|team_budget|\n",
      "+-----------+\n",
      "|  12957.076|\n",
      "|  2403.3704|\n",
      "|  3390.3755|\n",
      "|  13547.429|\n",
      "|   9678.333|\n",
      "+-----------+\n",
      "only showing top 5 rows"
     ]
    }
   ],
   "source": [
    "featurestore.get_feature(\n",
    "    \"team_budget\", \n",
    "    featurestore=featurestore.project_featurestore(), \n",
    "    featuregroup=\"teams_features\", \n",
    "    featuregroup_version = 1,\n",
    "    dataframe_type = \"spark\"\n",
    ").show(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fetch an Entire Feature Group\n",
    "\n",
    "You can get an entire featuregroup from the API. If no feature store is provided the API will default to the project's feature store, if no version is provided it will default to version 1 of the feature group. The default return format is as a spark dataframe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "SQL string for the query created successfully\n",
      "Running sql: SELECT * FROM teams_features_1 against offline feature store\n",
      "+-----------+-------+-------------+\n",
      "|team_budget|team_id|team_position|\n",
      "+-----------+-------+-------------+\n",
      "|  12957.076|      1|            1|\n",
      "|  2403.3704|      2|            2|\n",
      "|  3390.3755|      3|            3|\n",
      "|  13547.429|      4|            4|\n",
      "|   9678.333|      5|            5|\n",
      "+-----------+-------+-------------+\n",
      "only showing top 5 rows"
     ]
    }
   ],
   "source": [
    "featurestore.get_featuregroup(\"teams_features\").show(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The default parameters can be overriden:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "SQL string for the query created successfully\n",
      "Running sql: SELECT * FROM teams_features_1 against offline feature store\n",
      "+-----------+-------+-------------+\n",
      "|team_budget|team_id|team_position|\n",
      "+-----------+-------+-------------+\n",
      "|  12957.076|      1|            1|\n",
      "|  2403.3704|      2|            2|\n",
      "|  3390.3755|      3|            3|\n",
      "|  13547.429|      4|            4|\n",
      "|   9678.333|      5|            5|\n",
      "+-----------+-------+-------------+\n",
      "only showing top 5 rows"
     ]
    }
   ],
   "source": [
    "featurestore.get_featuregroup(\n",
    "    \"teams_features\", \n",
    "    featurestore=featurestore.project_featurestore(), \n",
    "    featuregroup_version = 1,\n",
    "    dataframe_type = \"spark\"\n",
    ").show(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fetch A Set of Features\n",
    "\n",
    "When retrieving a list of features from the featurestore, the hops-util-py library will infer which featuregroup the features belongs to by querying the metastore. If the features reside in different featuregroups, the library will also try to infer how to join the features together based on common columns. If the JOIN query cannot be inferred due to existence of multiple features with the same name or non-obvious JOIN query, the user need to supply enough information to the API call to be able to query the featurestore. If the user already knows the JOIN query it can also run featurestore.sql(joinQuery) directly (an example of this is shown further down in this notebook). If no featurestore is provided the API will default to the project's featurestore."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example of querying the feature store for a list of features without specifying the feature groups and feature store:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "Logical query plan for getting 3 features from the featurestore created successfully\n",
      "SQL string for the query created successfully\n",
      "Running sql: SELECT average_player_age, team_budget, average_attendance FROM players_features_1 JOIN teams_features_1 JOIN attendances_features_1 ON players_features_1.`team_id`=teams_features_1.`team_id` AND players_features_1.`team_id`=attendances_features_1.`team_id` against offline feature store\n",
      "+------------------+-----------+------------------+\n",
      "|average_player_age|team_budget|average_attendance|\n",
      "+------------------+-----------+------------------+\n",
      "|             24.85|    7307.94|         19595.973|\n",
      "|             25.45|   7326.092|          6462.462|\n",
      "|              25.4|   3555.235|          7226.672|\n",
      "|             25.91|  910.39325|         3189.8455|\n",
      "|             26.63|  10290.323|         4964.6475|\n",
      "+------------------+-----------+------------------+\n",
      "only showing top 5 rows"
     ]
    }
   ],
   "source": [
    "featurestore.get_features(\n",
    "    [\"team_budget\", \"average_attendance\", \"average_player_age\"]\n",
    ").show(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also explicitly specify the feature groups where the features reside. Either the feature groups and versions can be specified by prepending feature names with `<feature group name>_<feature group version.`, or by providing a dict with entries of `<feature group name> -> <feature group version>`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "Logical query plan for getting 3 features from the featurestore created successfully\n",
      "SQL string for the query created successfully\n",
      "Running sql: SELECT attendances_features_1.average_attendance, teams_features_1.team_budget, players_features_1.average_player_age FROM attendances_features_1 JOIN teams_features_1 JOIN players_features_1 ON attendances_features_1.`team_id`=teams_features_1.`team_id` AND attendances_features_1.`team_id`=players_features_1.`team_id` against offline feature store\n",
      "+------------------+-----------+------------------+\n",
      "|average_attendance|team_budget|average_player_age|\n",
      "+------------------+-----------+------------------+\n",
      "|         19595.973|    7307.94|             24.85|\n",
      "|          6462.462|   7326.092|             25.45|\n",
      "|          7226.672|   3555.235|              25.4|\n",
      "|         3189.8455|  910.39325|             25.91|\n",
      "|          9405.213|  12474.419|             25.78|\n",
      "+------------------+-----------+------------------+\n",
      "only showing top 5 rows"
     ]
    }
   ],
   "source": [
    "featurestore.get_features(\n",
    "    [\"teams_features_1.team_budget\", \n",
    "     \"attendances_features_1.average_attendance\", \n",
    "     \"players_features_1.average_player_age\"]\n",
    ").show(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "Logical query plan for getting 3 features from the featurestore created successfully\n",
      "SQL string for the query created successfully\n",
      "Running sql: SELECT average_player_age, team_budget, average_attendance FROM teams_features_1 JOIN players_features_1 JOIN attendances_features_1 ON teams_features_1.`team_id`=players_features_1.`team_id` AND teams_features_1.`team_id`=attendances_features_1.`team_id` against offline feature store\n",
      "+------------------+-----------+------------------+\n",
      "|average_player_age|team_budget|average_attendance|\n",
      "+------------------+-----------+------------------+\n",
      "|             24.85|    7307.94|         19595.973|\n",
      "|             25.45|   7326.092|          6462.462|\n",
      "|              25.4|   3555.235|          7226.672|\n",
      "|             25.91|  910.39325|         3189.8455|\n",
      "|             26.63|  10290.323|         4964.6475|\n",
      "+------------------+-----------+------------------+\n",
      "only showing top 5 rows"
     ]
    }
   ],
   "source": [
    "featurestore.get_features(\n",
    "    [\"team_budget\", \"average_attendance\", \"average_player_age\"],\n",
    "    featurestore=featurestore.project_featurestore(),\n",
    "    featuregroups_version_dict={\n",
    "        \"teams_features\": 1, \n",
    "        \"attendances_features\": 1,\n",
    "        \"players_features\": 1\n",
    "    }\n",
    ").show(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you have a lot of name collisions and it is not obvious how to infer the JOIN query to get the features from the feature store. You can explicitly specify the argument `join_key` to the API (or you can provide the entire SQL query using the API method `.sql` as we will demonstrate later on in the notebook)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "Logical query plan for getting 3 features from the featurestore created successfully\n",
      "SQL string for the query created successfully\n",
      "Running sql: SELECT average_player_age, team_budget, average_attendance FROM teams_features_1 JOIN attendances_features_1 JOIN players_features_1 ON teams_features_1.`team_id`=attendances_features_1.`team_id` AND teams_features_1.`team_id`=players_features_1.`team_id` against offline feature store\n",
      "+------------------+-----------+------------------+\n",
      "|average_player_age|team_budget|average_attendance|\n",
      "+------------------+-----------+------------------+\n",
      "|             24.85|    7307.94|         19595.973|\n",
      "|             25.45|   7326.092|          6462.462|\n",
      "|              25.4|   3555.235|          7226.672|\n",
      "|             25.91|  910.39325|         3189.8455|\n",
      "|             25.78|  12474.419|          9405.213|\n",
      "+------------------+-----------+------------------+\n",
      "only showing top 5 rows"
     ]
    }
   ],
   "source": [
    "featurestore.get_features(\n",
    "    [\"team_budget\", \"average_attendance\", \"average_player_age\"],\n",
    "    featurestore=featurestore.project_featurestore(),\n",
    "    featuregroups_version_dict={\n",
    "        \"teams_features\": 1, \n",
    "        \"attendances_features\": 1,\n",
    "        \"players_features\": 1\n",
    "    },\n",
    "    join_key = \"team_id\",\n",
    "    dataframe_type = \"spark\"\n",
    ").show(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Advanced Eamples of Fetching Sets of Features and Common Pitfalls"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Getting 12 features from 4 different feature groups:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "Logical query plan for getting 12 features from the featurestore created successfully\n",
      "SQL string for the query created successfully\n",
      "Running sql: SELECT team_budget, average_position, sum_player_rating, average_attendance, average_player_worth, sum_player_worth, sum_position, sum_attendance, average_player_rating, team_position, sum_player_age, average_player_age FROM teams_features_1 JOIN season_scores_features_1 JOIN players_features_1 JOIN attendances_features_1 ON teams_features_1.`team_id`=season_scores_features_1.`team_id` AND teams_features_1.`team_id`=players_features_1.`team_id` AND teams_features_1.`team_id`=attendances_features_1.`team_id` against offline feature store\n",
      "+-----------+----------------+-----------------+------------------+--------------------+----------------+------------+--------------+---------------------+-------------+--------------+------------------+\n",
      "|team_budget|average_position|sum_player_rating|average_attendance|average_player_worth|sum_player_worth|sum_position|sum_attendance|average_player_rating|team_position|sum_player_age|average_player_age|\n",
      "+-----------+----------------+-----------------+------------------+--------------------+----------------+------------+--------------+---------------------+-------------+--------------+------------------+\n",
      "|  12474.419|           34.35|         88129.83|          9405.213|           888.29443|       88829.445|       687.0|     188104.27|             881.2983|            9|        2578.0|             25.78|\n",
      "|  1621.1936|            40.3|         46779.38|          7118.376|           490.94702|       49094.703|       806.0|     142367.52|             467.7938|           17|        2601.0|             26.01|\n",
      "|  16758.066|           55.15|        32269.797|          3271.934|           307.87268|       30787.268|      1103.0|      65438.68|            322.69797|           26|        2565.0|             25.65|\n",
      "|  3966.3591|            57.1|        29779.197|         4074.8047|           298.78235|       29878.234|      1142.0|      81496.09|            297.79196|           27|        2550.0|              25.5|\n",
      "|    7307.94|           28.15|        131123.84|         19595.973|           1435.2465|       143524.64|       563.0|     391919.47|            1311.2384|            6|        2485.0|             24.85|\n",
      "+-----------+----------------+-----------------+------------------+--------------------+----------------+------------+--------------+---------------------+-------------+--------------+------------------+\n",
      "only showing top 5 rows"
     ]
    }
   ],
   "source": [
    "featurestore.get_features(\n",
    "    [\"team_budget\", \"average_attendance\", \"average_player_age\",\n",
    "    \"team_position\", \"sum_attendance\", \n",
    "     \"average_player_rating\", \"average_player_worth\", \"sum_player_age\",\n",
    "     \"sum_player_rating\", \"sum_player_worth\", \"sum_position\", \n",
    "     \"average_position\"\n",
    "    ]\n",
    ").show(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Free Text SQL Query from the Feature Store\n",
    "\n",
    "For complex queries that cannot be inferred by the helper functions, enter the sql directly to the method `featurestore.sql()` it will default to the project specific feature store but you can also specify it explicitly. If you are proficient in SQL, this is the most efficient and preferred way to query the feature store."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Without specifying the feature store the query will by default be run against the project's feature store:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "Running sql: SELECT * FROM teams_features_1 WHERE team_position < 5 against offline feature store\n",
      "+-----------+-------+-------------+\n",
      "|team_budget|team_id|team_position|\n",
      "+-----------+-------+-------------+\n",
      "|  12957.076|      1|            1|\n",
      "|  2403.3704|      2|            2|\n",
      "|  3390.3755|      3|            3|\n",
      "|  13547.429|      4|            4|\n",
      "+-----------+-------+-------------+"
     ]
    }
   ],
   "source": [
    "featurestore.sql(\"SELECT * FROM teams_features_1 WHERE team_position < 5\").show(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also specify the featurestore to query and the return format explicitly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "Running sql: SELECT * FROM teams_features_1 WHERE team_position < 5 against offline feature store\n",
      "+-----------+-------+-------------+\n",
      "|team_budget|team_id|team_position|\n",
      "+-----------+-------+-------------+\n",
      "|  12957.076|      1|            1|\n",
      "|  2403.3704|      2|            2|\n",
      "|  3390.3755|      3|            3|\n",
      "|  13547.429|      4|            4|\n",
      "+-----------+-------+-------------+"
     ]
    }
   ],
   "source": [
    "featurestore.sql(\"SELECT * FROM teams_features_1 WHERE team_position < 5\",\n",
    "                featurestore=featurestore.project_featurestore(), \n",
    "                 dataframe_type = \"spark\").show(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Featuregroup Visualization\n",
    "\n",
    "As you will see later on in this tutorial, when writing to the featurestore there is an option to also compute statistics of the features. The computed statistics will be stored as attached metadata of featuregroups and visualized in the feature registry. You can also access the statistics from the python API and visualize it in Jupyter notebooks in `%%local`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Feature Distributions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Remember to add %%matplotlib inline when doing visualizations in Jupyter notebooks\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x1152 with 8 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%local\n",
    "featurestore.visualize_featuregroup_distributions(\"players_features\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also override default parameters and configure the plotting options:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Remember to add %%matplotlib inline when doing visualizations in Jupyter notebooks\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x648 with 8 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%local\n",
    "featurestore.visualize_featuregroup_distributions(\"players_features\", \n",
    "                                                  featurestore=featurestore.project_featurestore(), \n",
    "                                                  featuregroup_version=1, \n",
    "                                                  figsize=(12, 9),\n",
    "                                                  color='lightblue', \n",
    "                                                  log=False, \n",
    "                                                  align=\"center\", \n",
    "                                                  plot=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also compute the figure in the spark kernel (don't have to use `%%local` then) and save it to HDFS for later viewing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Started copying local path players_features_distributions.png to hdfs path hdfs://172.31.22.2:8020/Projects/demo_featurestore_admin000/Resources//players_features_distributions.png\n",
      "\n",
      "Finished copying"
     ]
    }
   ],
   "source": [
    "from hops import hdfs\n",
    "fig = featurestore.visualize_featuregroup_distributions(\"players_features\", plot=False)\n",
    "fig.savefig(\"players_features_distributions.png\")\n",
    "hdfs.copy_to_hdfs(\"players_features_distributions.png\", \"Resources/\", overwrite=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Feature Correlations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Remember to add %%matplotlib inline when doing visualizations in Jupyter notebooks\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x864 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%local\n",
    "featurestore.visualize_featuregroup_correlations(\"players_features\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also override default parameters and configure the plotting options:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Remember to add %%matplotlib inline when doing visualizations in Jupyter notebooks\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%local\n",
    "featurestore.visualize_featuregroup_correlations(\"players_features\", \n",
    "                                                 featurestore=None, \n",
    "                                                 featuregroup_version=1, \n",
    "                                                 figsize=(8,6),\n",
    "                                                 cmap=\"coolwarm\", \n",
    "                                                 annot=True, \n",
    "                                                 fmt=\".2f\", \n",
    "                                                 linewidths=.05, \n",
    "                                                 plot=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also compute the figure in the spark kernel (don't have to use %%local then) and save it to HDFS for later viewing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Started copying local path players_features_correlations.png to hdfs path hdfs://172.31.22.2:8020/Projects/demo_featurestore_admin000/Resources//players_features_correlations.png\n",
      "\n",
      "Finished copying"
     ]
    }
   ],
   "source": [
    "from hops import hdfs\n",
    "fig = featurestore.visualize_featuregroup_correlations(\"players_features\", plot=False)\n",
    "fig.savefig(\"players_features_correlations.png\")\n",
    "hdfs.copy_to_hdfs(\"players_features_correlations.png\", \"Resources/\", overwrite=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Feature Clusters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Remember to add %%matplotlib inline when doing visualizations in Jupyter notebooks\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x864 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%local\n",
    "featurestore.visualize_featuregroup_clusters(\"players_features\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also override default parameters and configure the plotting options:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Remember to add %%matplotlib inline when doing visualizations in Jupyter notebooks\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%local\n",
    "featurestore.visualize_featuregroup_clusters(\"players_features\", \n",
    "                                featurestore=None, \n",
    "                                featuregroup_version=1, \n",
    "                                figsize=(8,6),\n",
    "                                plot=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also compute the figure in the spark kernel (don't have to use %%local then) and save it to HDFS for later viewing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Started copying local path players_features_clusters.png to hdfs path hdfs://172.31.22.2:8020/Projects/demo_featurestore_admin000/Resources//players_features_clusters.png\n",
      "\n",
      "Finished copying"
     ]
    }
   ],
   "source": [
    "from hops import hdfs\n",
    "fig = featurestore.visualize_featuregroup_clusters(\"players_features\", plot=False)\n",
    "fig.savefig(\"players_features_clusters.png\")\n",
    "hdfs.copy_to_hdfs(\"players_features_clusters.png\", \"Resources/\", overwrite=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Descriptive Stats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/srv/hops/anaconda/anaconda/envs/demo_featurestore_admin000/lib/python3.6/site-packages/autovizwidget/widget/utils.py:50: FutureWarning:\n",
      "\n",
      "A future version of pandas will default to `skipna=True`. To silence this warning, pass `skipna=True|False` explicitly.\n",
      "\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9e04181799464da5815cfb9ae5549c09",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(HBox(children=(HTML(value='Type:'), Button(description='Table', layout=Layout(width='70px'), st…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "49eefa96d770408dbf6f0370b077ba47",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%local\n",
    "desc_stats_df = featurestore.visualize_featuregroup_descriptive_stats(\"players_features\")\n",
    "desc_stats_df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since descriptive stats is just a pandas table and not a matplotlib figure it does not need a DISPLAY to work, so you can run it from the spark driver or executor as well:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   metric  sum_player_rating  ...  sum_player_age  average_player_age\n",
      "0  stddev         118708.750  ...        52.29132            0.522913\n",
      "1     min          15096.327  ...      2434.00000           24.340000\n",
      "2    mean          71738.375  ...      2556.84000           25.568400\n",
      "3   count             50.000  ...        50.00000           50.000000\n",
      "4     max         719186.300  ...      2700.00000           27.000000\n",
      "\n",
      "[5 rows x 8 columns]"
     ]
    }
   ],
   "source": [
    "desc_stats_df = featurestore.visualize_featuregroup_descriptive_stats(\"players_features\")\n",
    "desc_stats_df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Writing to the Feature Store\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating New Feature Groups\n",
    "\n",
    "Feature Groups can be created using the Feature Store API and the `create_featuregroup()` function. Metadata of a feature group can later on be browsed and edited from the Feature Registry (UI in Hopsworks)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets create a new featuregroup called **teams_features_spanish** that contains the same contents as the feature group teams_features except the the columns are renamed to spanish"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "SQL string for the query created successfully\n",
      "Running sql: SELECT * FROM teams_features_1 against offline feature store"
     ]
    }
   ],
   "source": [
    "teams_features_1_df = featurestore.get_featuregroup(\"teams_features\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "teams_features_2_df = teams_features_1_df.withColumnRenamed(\n",
    "    \"team_id\", \"equipo_id\").withColumnRenamed(\n",
    "    \"team_budget\", \"equipo_presupuesto\").withColumnRenamed(\n",
    "    \"team_position\", \"equipo_posicion\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+------------------+---------+---------------+\n",
      "|equipo_presupuesto|equipo_id|equipo_posicion|\n",
      "+------------------+---------+---------------+\n",
      "|         12957.076|        1|              1|\n",
      "|         2403.3704|        2|              2|\n",
      "|         3390.3755|        3|              3|\n",
      "|         13547.429|        4|              4|\n",
      "|          9678.333|        5|              5|\n",
      "+------------------+---------+---------------+\n",
      "only showing top 5 rows"
     ]
    }
   ],
   "source": [
    "teams_features_2_df.show(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets now create a new featuregroup using the transformed dataframe (we'll explain the statistics part later on in this notebook)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Registering feature metadata...\n",
      "Registering feature metadata... [COMPLETE]\n",
      "Writing feature data to offline feature group (Hive)...\n",
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "Writing feature data to offline feature group (Hive)... [COMPLETE]\n",
      "Feature group created successfully"
     ]
    }
   ],
   "source": [
    "featurestore.create_featuregroup(\n",
    "    teams_features_2_df,\n",
    "    \"teams_features_spanish\",\n",
    "    description=\"a spanish version of teams_features\",\n",
    "    descriptive_statistics=False,\n",
    "    feature_correlation=False,\n",
    "    feature_histograms=False,\n",
    "    cluster_analysis=False\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By default the new featuregroup will be created in the project's featurestore and the statistics for the new featuregroup will be computed based on the provided spark dataframe. You can configure this behaviour by modifying the default arguments and filling in extra metadata."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Registering feature metadata...\n",
      "Registering feature metadata... [COMPLETE]\n",
      "Writing feature data to offline feature group (Hive)...\n",
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "Writing feature data to offline feature group (Hive)... [COMPLETE]\n",
      "Feature group created successfully"
     ]
    }
   ],
   "source": [
    "featurestore.create_featuregroup(\n",
    "    teams_features_2_df,\n",
    "    \"teams_features_spanish\",\n",
    "    description=\"a spanish version of teams_features\",\n",
    "    descriptive_statistics=False,\n",
    "    feature_correlation=False,\n",
    "    feature_histograms=False,\n",
    "    cluster_analysis=False,\n",
    "    featurestore=featurestore.project_featurestore(),\n",
    "    featuregroup_version=2\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Create an On-Demand Feature Group\n",
    "\n",
    "Feature Groups in Hopsworks can be of two types: \n",
    "\n",
    "- **Cached Feature Groups** are pre-computed and stored inside Hopsworks as Hive tables for historical data and MySQL Cluster tables for online data.\n",
    "- **On-Demand Feature Groups** are computed on-demand using a JDBC connector and a SQL query. On-Demand Feature Groups can be stored in any JDBC-compliant data store.\n",
    "\n",
    "To create an on-demand feature group, you must first configure a storage connector ti the JDBC backend that you want to query and then you can use the method `create_on_demand_featuregroup()` to create the on-demand feature group.\n",
    "\n",
    "By default, a Feature Store in Hopsworks has two default JDBC storage connectors configured:\n",
    "\n",
    "- `project_name`: a storage connector for the Hive database of the project\n",
    "- `project_name_featurestore a storage connector` for the Feature Store database of the project"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can list the available storage connectors in the feature store, using the method `get_storage_connectors()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('demo_featurestore_admin000_featurestore', 'JDBC'), ('demo_featurestore_admin000', 'JDBC'), ('demo_featurestore_admin000_meb1_onlinefeaturestore', 'JDBC'), ('demo_featurestore_admin000_Training_Datasets', 'HOPSFS')]"
     ]
    }
   ],
   "source": [
    "featurestore.get_storage_connectors()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we inspect the Feature Store hive database, we can see that there is a table called `games_features_1`, lets use the JDBC connector called `<project_name>_featurestore` and the SQL string `\"SELECT * FROM games_features_1 WHERE score > 1\"` to create an on-demand feature group called `games_features_on_demand`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "Running sql: show tables against offline feature store\n",
      "+--------------------+--------------------+-----------+\n",
      "|            database|           tableName|isTemporary|\n",
      "+--------------------+--------------------+-----------+\n",
      "|demo_featurestore...|attendances_featu...|      false|\n",
      "|demo_featurestore...|    games_features_1|      false|\n",
      "|demo_featurestore...|games_features_hu...|      false|\n",
      "|demo_featurestore...|houses_for_sale_f...|      false|\n",
      "|demo_featurestore...|  players_features_1|      false|\n",
      "+--------------------+--------------------+-----------+\n",
      "only showing top 5 rows"
     ]
    }
   ],
   "source": [
    "featurestore.sql(\"show tables\").show(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "Running sql: describe games_features_1 against offline feature store\n",
      "+------------+---------+-------+\n",
      "|    col_name|data_type|comment|\n",
      "+------------+---------+-------+\n",
      "|away_team_id|      int|      -|\n",
      "|home_team_id|      int|      -|\n",
      "|       score|      int|      -|\n",
      "+------------+---------+-------+"
     ]
    }
   ],
   "source": [
    "featurestore.sql(\"describe games_features_1\").show(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Feature group created successfully"
     ]
    }
   ],
   "source": [
    "from hops import hdfs\n",
    "query = \"SELECT * FROM games_features_1 WHERE score > 1\"\n",
    "storage_connector = hdfs.project_name() + \"_featurestore\"\n",
    "featuregroup_name = \"games_features_on_demand\"\n",
    "featurestore.create_on_demand_featuregroup(query, featuregroup_name, storage_connector)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On-Demand Feature Groups can be queried just like cached feature groups. When you query an on-demand feature group, it will open a JDBC connection and apply the associated SQL query and return the resulting dataframe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+------------+------------+-----+\n",
      "|away_team_id|home_team_id|score|\n",
      "+------------+------------+-----+\n",
      "|          46|          32|    3|\n",
      "|          15|          13|    2|\n",
      "|          50|           1|    3|\n",
      "|          36|          39|    2|\n",
      "|          14|           8|    3|\n",
      "+------------+------------+-----+\n",
      "only showing top 5 rows"
     ]
    }
   ],
   "source": [
    "featurestore.get_featuregroup(\"games_features_on_demand\").show(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets create an on-demand feature group with the same JDBC connector and the table `players_features_1`, and see how we can make queries that join on-demand feature groups with cached feature groups dynamically."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Feature group created successfully"
     ]
    }
   ],
   "source": [
    "from hops import hdfs\n",
    "query = \"SELECT average_player_age as average_player_age_on_dmd, average_player_worth as average_player_worth_on_dmd, team_id FROM players_features_1\"\n",
    "storage_connector = hdfs.project_name() + \"_featurestore\"\n",
    "featuregroup_name = \"players_features_on_demand\"\n",
    "featurestore.create_on_demand_featuregroup(query, featuregroup_name, storage_connector)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you make a query to the feature store that cross multiple feature groups, including on-demand feature groups. The Query Planner that comes with the Python SDK will first fetch the on-demand feature groups and then register them as SparkSQL temporary tables, before joining them with the features from the cached feature groups.\n",
    "\n",
    "Note that when querying on-demand-featuregroups, you typically have to supply the `join_key` and the `featuregroups_version_dict` manually as the query planner will often not have information about the columns in the on-demand feature groups and hence cannot infer the join key or infer in which on-demand feature group a certain feature exists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running sql: use demo_featurestore_admin000_featurestore\n",
      "Logical query plan for getting 4 features from the featurestore created successfully\n",
      "Registered on-demand feature group: players_features_on_demand with version: 1 as temporary table: players_features_on_demand_1\n",
      "SQL string for the query created successfully\n",
      "Running sql: SELECT average_player_age_on_dmd, average_player_worth_on_dmd, average_attendance, sum_attendance FROM players_features_on_demand_1 JOIN attendances_features_1 ON players_features_on_demand_1.`team_id`=attendances_features_1.`team_id`\n",
      "+-------------------------+---------------------------+------------------+--------------+\n",
      "|average_player_age_on_dmd|average_player_worth_on_dmd|average_attendance|sum_attendance|\n",
      "+-------------------------+---------------------------+------------------+--------------+\n",
      "|                    24.63|                   231.8708|         3587.5015|      71750.03|\n",
      "|                    25.71|                  223.71338|         2532.1638|     50643.277|\n",
      "|                    25.63|                  280.11465|         3397.8066|      67956.13|\n",
      "|                    25.65|                  307.87268|          3271.934|      65438.68|\n",
      "|                     25.5|                  298.78235|         4074.8047|      81496.09|\n",
      "+-------------------------+---------------------------+------------------+--------------+\n",
      "only showing top 5 rows"
     ]
    }
   ],
   "source": [
    "featurestore.get_features([\"average_player_age_on_dmd\", \"average_player_worth_on_dmd\", \"average_attendance\", \n",
    "                           \"sum_attendance\"],\n",
    "                         featuregroups_version_dict={\n",
    "                             \"players_features_on_demand\": 1, \n",
    "                             \"attendances_features\": 1\n",
    "                         }, join_key=\"team_id\").show(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "Logical query plan for getting 1 feature from the featurestore created successfully\n",
      "Registered on-demand feature group: players_features_on_demand with version: 1 as temporary table: players_features_on_demand_1\n",
      "SQL string for the query created successfully\n",
      "Running sql: SELECT average_player_age_on_dmd FROM players_features_on_demand_1 against offline feature store\n",
      "+-------------------------+\n",
      "|average_player_age_on_dmd|\n",
      "+-------------------------+\n",
      "|                    24.63|\n",
      "|                    25.71|\n",
      "|                    25.63|\n",
      "|                    25.65|\n",
      "|                     25.5|\n",
      "+-------------------------+\n",
      "only showing top 5 rows"
     ]
    }
   ],
   "source": [
    "featurestore.get_feature(\"average_player_age_on_dmd\", featuregroup=\"players_features_on_demand\").show(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Create a New Version of A Feature Group\n",
    "\n",
    "To create a new version, simply use the `create_featuregroup` method and specify the version argument:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Registering feature metadata...\n",
      "Registering feature metadata... [COMPLETE]\n",
      "Writing feature data to offline feature group (Hive)...\n",
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "Writing feature data to offline feature group (Hive)... [COMPLETE]\n",
      "Feature group created successfully"
     ]
    }
   ],
   "source": [
    "featurestore.create_featuregroup(\n",
    "    teams_features_2_df,\n",
    "    \"teams_features_spanish\",\n",
    "    description=\"a spanish version of teams_features\",\n",
    "    descriptive_statistics=False,\n",
    "    feature_correlation=False,\n",
    "    feature_histograms=False,\n",
    "    cluster_analysis=False,\n",
    "    featuregroup_version=3\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Get the Latest Version of a Feature Group (0 if no version exist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3"
     ]
    }
   ],
   "source": [
    "latest_version = featurestore.get_latest_featuregroup_version(\"teams_features_spanish\")\n",
    "latest_version"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Update Metadata Cache\n",
    "\n",
    "Note: By default, the python client will only fetch the featurestore metadata once and then cache it on the client. If you need to update the cache you can use the command:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<hops.featurestore_impl.dao.common.featurestore_metadata.FeaturestoreMetadata object at 0x7f0b799b07b8>"
     ]
    }
   ],
   "source": [
    "featurestore.get_featurestore_metadata(update_cache=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Featuregroup Partitioning \n",
    "\n",
    "Cached Featuregroups are stored as Hive tables, meaning that they can be partitioned for improved **read-query** performance. We use dynamic partitioning where the partition keys are specified on creation of a featuregroup. To set the partitions, simply specify the `partition_by` argument to `create_featuregroup()`. The `partition_by` argument should be set as a python list of the columns that you want to partition the table on, see examples below.\n",
    "\n",
    "Partitioning is not supported for training datasets as those are meant to be immutable blobs used for training (e.g petastorm or tfrecords), and do not need to be optimized for query performance. \n",
    "\n",
    "Feature groups in Hive might need to be read-query optimized however, since it might be used to create a lot of different training datasets, using different subsets of features."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As an example we can take the `games_features` featuregroup created by the featurestore tour and re-create it as a new featuregroup called `games_features_partitioned` where we partition on the `score` column."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "SQL string for the query created successfully\n",
      "Running sql: SELECT * FROM games_features_1 against offline feature store"
     ]
    }
   ],
   "source": [
    "games_features_df = featurestore.get_featuregroup(\"games_features\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Registering feature metadata...\n",
      "Registering feature metadata... [COMPLETE]\n",
      "Writing feature data to offline feature group (Hive)...\n",
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "Writing feature data to offline feature group (Hive)... [COMPLETE]\n",
      "Feature group created successfully"
     ]
    }
   ],
   "source": [
    "featurestore.create_featuregroup(\n",
    "    games_features_df,\n",
    "    \"games_features_partitioned\",\n",
    "    description=\"games_features partitioned by score\",\n",
    "    descriptive_statistics=False,\n",
    "    feature_correlation=False,\n",
    "    feature_histograms=False,\n",
    "    cluster_analysis=False,\n",
    "    partition_by=[\"score\"]\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also partition on multiple columns (watch out so that the number of partitions don't get too many though). Also note that it is not allowed to partition on the primary key, which does not make sense either since the primary key should be unique. If you try to partition on the primary key, the partitioning will simply be skipped. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Registering feature metadata...\n",
      "Registering feature metadata... [COMPLETE]\n",
      "Writing feature data to offline feature group (Hive)...\n",
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "Writing feature data to offline feature group (Hive)... [COMPLETE]\n",
      "Feature group created successfully"
     ]
    }
   ],
   "source": [
    "featurestore.create_featuregroup(\n",
    "    games_features_df,\n",
    "    \"games_features_double_partitioned\",\n",
    "    description=\"games_features partitioned by score and away_team_id\",\n",
    "    descriptive_statistics=False,\n",
    "    feature_correlation=False,\n",
    "    feature_histograms=False,\n",
    "    cluster_analysis=False,\n",
    "    partition_by=[\"score\", \"home_team_id\"]\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To verify the partitions we can use the utility function `get_featuregroup_partitions`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "Running sql: SHOW PARTITIONS games_features_partitioned_1 against offline feature store\n",
      "+---------+\n",
      "|partition|\n",
      "+---------+\n",
      "|  score=1|\n",
      "|  score=2|\n",
      "|  score=3|\n",
      "+---------+"
     ]
    }
   ],
   "source": [
    "featurestore.get_featuregroup_partitions(\"games_features_partitioned\").show(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "Running sql: SHOW PARTITIONS games_features_double_partitioned_1 against offline feature store\n",
      "+--------------------+\n",
      "|           partition|\n",
      "+--------------------+\n",
      "|home_team_id=1/sc...|\n",
      "|home_team_id=1/sc...|\n",
      "|home_team_id=10/s...|\n",
      "|home_team_id=10/s...|\n",
      "|home_team_id=10/s...|\n",
      "|home_team_id=11/s...|\n",
      "|home_team_id=11/s...|\n",
      "|home_team_id=11/s...|\n",
      "|home_team_id=12/s...|\n",
      "|home_team_id=12/s...|\n",
      "+--------------------+\n",
      "only showing top 10 rows"
     ]
    }
   ],
   "source": [
    "featurestore.get_featuregroup_partitions(\"games_features_double_partitioned\").show(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also specify the optional arguments for `get_featuregroup_partitions`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "Running sql: SHOW PARTITIONS games_features_partitioned_1 against offline feature store\n",
      "+---------+\n",
      "|partition|\n",
      "+---------+\n",
      "|  score=1|\n",
      "|  score=2|\n",
      "|  score=3|\n",
      "+---------+"
     ]
    }
   ],
   "source": [
    "featurestore.get_featuregroup_partitions(\"games_features_partitioned\",\n",
    "                                         featurestore=featurestore.project_featurestore(),\n",
    "                                         featuregroup_version = 1,\n",
    "                                         dataframe_type=\"spark\").show(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you overwrite a table, it will pick up the old partitioning scheme it had before the overwrite: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "SQL string for the query created successfully\n",
      "Running sql: SELECT * FROM games_features_partitioned_1 against offline feature store\n",
      "Inserting data into offline feature group games_features_partitioned...\n",
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "Inserting data into offline feature group games_features_partitioned... [COMPLETE]\n",
      "Insertion into feature group was successful"
     ]
    }
   ],
   "source": [
    "featurestore.insert_into_featuregroup(games_features_df, \"games_features_partitioned\", mode=\"overwrite\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "Running sql: SHOW PARTITIONS games_features_partitioned_1 against offline feature store\n",
      "+---------+\n",
      "|partition|\n",
      "+---------+\n",
      "|  score=1|\n",
      "|  score=2|\n",
      "|  score=3|\n",
      "+---------+"
     ]
    }
   ],
   "source": [
    "featurestore.get_featuregroup_partitions(\"games_features_partitioned\").show(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Synchronize a Hive Table with the Feature Store\n",
    "\n",
    "The Feature Store SDK supports method for synchronizing existing Hive tables with the feature store, using `syncHiveTableWithFeaturestore`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create an example Hive Table (praxis in the feature store is to have `_version` suffix on the table):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyspark.sql import SQLContext\n",
    "from pyspark.sql.types import StructType, StructField, StringType, TimestampType, LongType, IntegerType, FloatType\n",
    "sqlContext = SQLContext(sc)\n",
    "schema = StructType([StructField(\"equipo_id\", IntegerType(), True),\n",
    "                     StructField(\"equipo_presupuesto\", FloatType(), True),\n",
    "                     StructField(\"equipo_posicion\", IntegerType(), True)\n",
    "                        ])\n",
    "sample_df = sqlContext.createDataFrame([(999, 41251.52, 1), (998, 1319.4, 8), (997, 21219.1, 2)], schema)\n",
    "spark.sql(\"use {}\".format(featurestore.project_featurestore()))\n",
    "sample_df.write.mode(\"overwrite\").saveAsTable(\"hive_fs_sync_example_1\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+---------------------------------------+-----------------------------------+-----------+\n",
      "|database                               |tableName                          |isTemporary|\n",
      "+---------------------------------------+-----------------------------------+-----------+\n",
      "|demo_featurestore_admin000_featurestore|attendances_features_1             |false      |\n",
      "|demo_featurestore_admin000_featurestore|games_features_1                   |false      |\n",
      "|demo_featurestore_admin000_featurestore|games_features_double_partitioned_1|false      |\n",
      "|demo_featurestore_admin000_featurestore|games_features_hudi_tour_1         |false      |\n",
      "|demo_featurestore_admin000_featurestore|games_features_partitioned_1       |false      |\n",
      "|demo_featurestore_admin000_featurestore|hive_fs_sync_example_1             |false      |\n",
      "|demo_featurestore_admin000_featurestore|houses_for_sale_featuregroup_3     |false      |\n",
      "|demo_featurestore_admin000_featurestore|players_features_1                 |false      |\n",
      "|demo_featurestore_admin000_featurestore|season_scores_features_1           |false      |\n",
      "|demo_featurestore_admin000_featurestore|teams_features_1                   |false      |\n",
      "|demo_featurestore_admin000_featurestore|teams_features_spanish_1           |false      |\n",
      "|demo_featurestore_admin000_featurestore|teams_features_spanish_2           |false      |\n",
      "|demo_featurestore_admin000_featurestore|teams_features_spanish_3           |false      |\n",
      "|demo_featurestore_admin000_featurestore|test_response_1                    |false      |\n",
      "|                                       |players_features_on_demand_1       |true       |\n",
      "+---------------------------------------+-----------------------------------+-----------+"
     ]
    }
   ],
   "source": [
    "spark.sql(\"show tables\").show(20, False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Synchronizing Hive Table: hive_fs_sync_example with Feature Store: demo_featurestore_admin000_featurestore\n",
      "Hive Table: hive_fs_sync_example was successfully synchronized with Feature Store: demo_featurestore_admin000_featurestore"
     ]
    }
   ],
   "source": [
    "featurestore.sync_hive_table_with_featurestore(\"hive_fs_sync_example\", \n",
    "                                               description=\"test Hive sync\", \n",
    "                                               featuregroup_version=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['teams_features_1', 'games_features_on_demand_tour_1', 'players_features_1', 'games_features_hudi_tour_1', 'games_features_1', 'attendances_features_1', 'season_scores_features_1', 'test_response_1', 'teams_features_spanish_2', 'teams_features_spanish_1', 'games_features_on_demand_1', 'teams_features_spanish_3', 'hive_fs_sync_example_1', 'games_features_partitioned_1', 'games_features_double_partitioned_1', 'players_features_on_demand_1']"
     ]
    }
   ],
   "source": [
    "featurestore.get_featuregroups()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "SQL string for the query created successfully\n",
      "Running sql: SELECT * FROM hive_fs_sync_example_1 against offline feature store\n",
      "+---------+------------------+---------------+\n",
      "|equipo_id|equipo_presupuesto|equipo_posicion|\n",
      "+---------+------------------+---------------+\n",
      "|      998|            1319.4|              8|\n",
      "|      997|           21219.1|              2|\n",
      "|      999|          41251.52|              1|\n",
      "+---------+------------------+---------------+"
     ]
    }
   ],
   "source": [
    "featurestore.get_featuregroup(\"hive_fs_sync_example\").show(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Inserting Into Existing Feature Groups\n",
    "\n",
    "A best practice when working with features in HopsML is to first figure out a model of feature groups and create them  using the Feature Registry UI. This will prepare the feature group schema and create the Hive tables. Once the empty feature groups are created, then you can insert into these tables directly."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets first get some sample data to insert"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyspark.sql import SQLContext\n",
    "from pyspark.sql.types import StructType, StructField, StringType, TimestampType, LongType, IntegerType, FloatType\n",
    "sqlContext = SQLContext(sc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "schema = StructType([StructField(\"equipo_id\", IntegerType(), True),\n",
    "                     StructField(\"equipo_presupuesto\", FloatType(), True),\n",
    "                     StructField(\"equipo_posicion\", IntegerType(), True)\n",
    "                        ])\n",
    "sample_df = sqlContext.createDataFrame([(999, 41251.52, 1), (998, 1319.4, 8), (997, 21219.1, 2)], schema)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+---------+------------------+---------------+\n",
      "|equipo_id|equipo_presupuesto|equipo_posicion|\n",
      "+---------+------------------+---------------+\n",
      "|      999|          41251.52|              1|\n",
      "|      998|            1319.4|              8|\n",
      "|      997|           21219.1|              2|\n",
      "+---------+------------------+---------------+"
     ]
    }
   ],
   "source": [
    "sample_df.show(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3"
     ]
    }
   ],
   "source": [
    "sample_df.count()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets inspect the contents of the featuregroup `teams_features_spanish` that we are going to insert the sample data into:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "SQL string for the query created successfully\n",
      "Running sql: SELECT * FROM teams_features_spanish_1 against offline feature store"
     ]
    }
   ],
   "source": [
    "spanish_team_features_df = featurestore.get_featuregroup(\n",
    "    \"teams_features_spanish\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+------------------+---------+---------------+\n",
      "|equipo_presupuesto|equipo_id|equipo_posicion|\n",
      "+------------------+---------+---------------+\n",
      "|         12957.076|        1|              1|\n",
      "|         2403.3704|        2|              2|\n",
      "|         3390.3755|        3|              3|\n",
      "|         13547.429|        4|              4|\n",
      "|          9678.333|        5|              5|\n",
      "+------------------+---------+---------------+\n",
      "only showing top 5 rows"
     ]
    }
   ],
   "source": [
    "spanish_team_features_df.show(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50"
     ]
    }
   ],
   "source": [
    "spanish_team_features_df.count()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can insert the sample data and verify the new contents of the featuregroup. By default the insert mode is \"append\", the featurestore is the project's featurestore, the version is 1 and statistics will be updated based on the previously made settings when the featuregroup was created (we cover statistics later on in this notebook)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "SQL string for the query created successfully\n",
      "Running sql: SELECT * FROM teams_features_spanish_1 against offline feature store\n",
      "Inserting data into offline feature group teams_features_spanish...\n",
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "Inserting data into offline feature group teams_features_spanish... [COMPLETE]\n",
      "Insertion into feature group was successful"
     ]
    }
   ],
   "source": [
    "featurestore.insert_into_featuregroup(\n",
    "    sample_df, \n",
    "    \"teams_features_spanish\"\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets now inspect the contents of the feature group to verify that the insertion was successful"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "SQL string for the query created successfully\n",
      "Running sql: SELECT * FROM teams_features_spanish_1 against offline feature store"
     ]
    }
   ],
   "source": [
    "spanish_team_features_df_updated = featurestore.get_featuregroup(\n",
    "    \"teams_features_spanish\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+------------------+---------+---------------+\n",
      "|equipo_presupuesto|equipo_id|equipo_posicion|\n",
      "+------------------+---------+---------------+\n",
      "|         12957.076|        1|              1|\n",
      "|         2403.3704|        2|              2|\n",
      "|         3390.3755|        3|              3|\n",
      "|         13547.429|        4|              4|\n",
      "|          9678.333|        5|              5|\n",
      "+------------------+---------+---------------+\n",
      "only showing top 5 rows"
     ]
    }
   ],
   "source": [
    "spanish_team_features_df_updated.show(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "53"
     ]
    }
   ],
   "source": [
    "spanish_team_features_df_updated.count()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also explicitly specify featurestore, featuregroup version and the insert mode:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "SQL string for the query created successfully\n",
      "Running sql: SELECT * FROM teams_features_spanish_1 against offline feature store\n",
      "Inserting data into offline feature group teams_features_spanish...\n",
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "Inserting data into offline feature group teams_features_spanish... [COMPLETE]\n",
      "Insertion into feature group was successful"
     ]
    }
   ],
   "source": [
    "featurestore.insert_into_featuregroup(\n",
    "    sample_df, \n",
    "    \"teams_features_spanish\", \n",
    "    featurestore=featurestore.project_featurestore(), \n",
    "    featuregroup_version=1, \n",
    "    mode=\"append\"\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "SQL string for the query created successfully\n",
      "Running sql: SELECT * FROM teams_features_spanish_1 against offline feature store\n",
      "56"
     ]
    }
   ],
   "source": [
    "featurestore.get_featuregroup(\"teams_features_spanish\").count()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The two supported insert modes are \"append\" and \"overwrite\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "SQL string for the query created successfully\n",
      "Running sql: SELECT * FROM teams_features_spanish_1 against offline feature store\n",
      "Inserting data into offline feature group teams_features_spanish...\n",
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "Inserting data into offline feature group teams_features_spanish... [COMPLETE]\n",
      "Insertion into feature group was successful"
     ]
    }
   ],
   "source": [
    "featurestore.insert_into_featuregroup(\n",
    "    sample_df, \n",
    "    \"teams_features_spanish\",\n",
    "    mode=\"overwrite\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "SQL string for the query created successfully\n",
      "Running sql: SELECT * FROM teams_features_spanish_1 against offline feature store\n",
      "+---------+---------------+------------------+\n",
      "|equipo_id|equipo_posicion|equipo_presupuesto|\n",
      "+---------+---------------+------------------+\n",
      "|      999|          41251|               1.0|\n",
      "|      998|           1319|               8.0|\n",
      "|      997|          21219|               2.0|\n",
      "+---------+---------------+------------------+"
     ]
    }
   ],
   "source": [
    "featurestore.get_featuregroup(\"teams_features_spanish\").show(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "SQL string for the query created successfully\n",
      "Running sql: SELECT * FROM teams_features_spanish_1 against offline feature store\n",
      "3"
     ]
    }
   ],
   "source": [
    "featurestore.get_featuregroup(\"teams_features_spanish\").count()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Import External Feature Datasets to the Feature Store\n",
    "\n",
    "Feature datasets stored externally to Hopsworks can be imported using the `import_featuregroup` primitive in the Featurestore SDK. For example, say that you have a dataset stored on S3 that you want to import. To import the dataset from S3, first configure an s3 connector for your feature store, e.g with name `my_s3_connector`. The connector is used for authenticating with S3 and for specifying your bucket name. Once the connector is configured, you can use the `import_featuregroup` function as follows:\n",
    "```python\n",
    "from hops import featurestore\n",
    "featurestore.import_featuregroup(\"my_s3_connector\", s3_bucket_path, \"fg_name\", data_format=\"tfrecords\")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Integrating the Feature Store with Pandas and Numpy\n",
    "\n",
    "The Hops Feature Store works natively with Spark, but you can easily connect it to your numpy/pandas/pure python pipelines as well (just recall that if you are working with big data, using libraries like numpy/pandas that are not distributed will not scale."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import datetime\n",
    "import time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Read Features from the Featue Store into a Pandas or Numpy Table\n",
    "\n",
    "To read from the feature store into pandas and numpy we just have to specify the optional argument `dataframe_type` that defaults to \"spark\". This argument decides the format of the returning dataframe. If you want the features returned to be in either pandas or numpy format you can specfy `dataframe_type='pandas'` or `dataframe_type='numpy'`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Reading Features into a Pandas Dataframe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "Logical query plan for getting 3 features from the featurestore created successfully\n",
      "SQL string for the query created successfully\n",
      "Running sql: SELECT average_player_age, team_budget, average_attendance FROM players_features_1 JOIN teams_features_1 JOIN attendances_features_1 ON players_features_1.`team_id`=teams_features_1.`team_id` AND players_features_1.`team_id`=attendances_features_1.`team_id` against offline feature store"
     ]
    }
   ],
   "source": [
    "pandas_df = featurestore.get_features([\"team_budget\", \"average_attendance\", \"average_player_age\"], \n",
    "                                      dataframe_type=\"pandas\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   average_player_age   team_budget  average_attendance\n",
      "0           24.850000   7307.939941        19595.972656\n",
      "1           25.450001   7326.091797         6462.461914\n",
      "2           25.400000   3555.235107         7226.671875\n",
      "3           25.910000    910.393250         3189.845459\n",
      "4           26.629999  10290.323242         4964.647461"
     ]
    }
   ],
   "source": [
    "pandas_df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Reading Features into a Numpy 2D Array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "Logical query plan for getting 3 features from the featurestore created successfully\n",
      "SQL string for the query created successfully\n",
      "Running sql: SELECT average_player_age, team_budget, average_attendance FROM players_features_1 JOIN teams_features_1 JOIN attendances_features_1 ON players_features_1.`team_id`=teams_features_1.`team_id` AND players_features_1.`team_id`=attendances_features_1.`team_id` against offline feature store"
     ]
    }
   ],
   "source": [
    "numpy_df = featurestore.get_features([\"team_budget\", \"average_attendance\", \"average_player_age\"], \n",
    "                                      dataframe_type=\"numpy\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(50, 3)"
     ]
    }
   ],
   "source": [
    "numpy_df.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Reading Features into a Python 2D List"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "Logical query plan for getting 3 features from the featurestore created successfully\n",
      "SQL string for the query created successfully\n",
      "Running sql: SELECT average_player_age, team_budget, average_attendance FROM players_features_1 JOIN teams_features_1 JOIN attendances_features_1 ON players_features_1.`team_id`=teams_features_1.`team_id` AND players_features_1.`team_id`=attendances_features_1.`team_id` against offline feature store"
     ]
    }
   ],
   "source": [
    "python_df = featurestore.get_features([\"team_budget\", \"average_attendance\", \"average_player_age\"], \n",
    "                                      dataframe_type=\"python\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50"
     ]
    }
   ],
   "source": [
    "len(python_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3"
     ]
    }
   ],
   "source": [
    "len(python_df[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Write Pandas or Numpy Tables into the Feature Store\n",
    "\n",
    "The feature store API natively supports dataframes in spark, pandas, python or numpy format for writing to the feature store. \n",
    "\n",
    "**Note** that since the feature store contains feature groups with documented schemas to allow easy joining of thousands of features in the future, inserting raw numpy arrays is not recommended. Numpy arrays and python lists do not have any associated schema so the library will infer the schema to be \"col_1, col_2, col_3... etc\". It is recommended that you think carefully in how to model your feature schema with naming of columns **before** you insert into the feature store so that it becomed easy to later join features across several feature groups by using a common join-column."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Writing a Pandas DataFrame to the Feature Store"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index(['average_player_age', 'team_budget', 'average_attendance'], dtype='object')"
     ]
    }
   ],
   "source": [
    "pandas_df.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's rename the columns to differentiate this feature group from existing ones in the feature store\n",
    "pandas_df.columns = [\"average_player_age_test\", \"team_budget_test\", \"average_attendance_test\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Registering feature metadata...\n",
      "Registering feature metadata... [COMPLETE]\n",
      "Writing feature data to offline feature group (Hive)...\n",
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "Writing feature data to offline feature group (Hive)... [COMPLETE]\n",
      "Feature group created successfully"
     ]
    }
   ],
   "source": [
    "featurestore.create_featuregroup(\n",
    "    pandas_df,\n",
    "    \"pandas_test_example\",\n",
    "    description=\"test featuregroup created from pandas dataframe\",\n",
    "    descriptive_statistics=False,\n",
    "    feature_correlation=False,\n",
    "    feature_histograms=False,\n",
    "    cluster_analysis=False\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "SQL string for the query created successfully\n",
      "Running sql: SELECT * FROM pandas_test_example_1 against offline feature store\n",
      "Inserting data into offline feature group pandas_test_example...\n",
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "Inserting data into offline feature group pandas_test_example... [COMPLETE]\n",
      "Insertion into feature group was successful"
     ]
    }
   ],
   "source": [
    "# All insert/create methods in the API supports spark, pandas, and numpy dataframes\n",
    "featurestore.insert_into_featuregroup(\n",
    "    pandas_df, \n",
    "    \"pandas_test_example\",\n",
    "    mode=\"overwrite\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Writing a Numpy 2D Array to the Feature Store"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Registering feature metadata...\n",
      "Registering feature metadata... [COMPLETE]\n",
      "Writing feature data to offline feature group (Hive)...\n",
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "Writing feature data to offline feature group (Hive)... [COMPLETE]\n",
      "Feature group created successfully"
     ]
    }
   ],
   "source": [
    "featurestore.create_featuregroup(\n",
    "    numpy_df,\n",
    "    \"numpy_test_example\",\n",
    "    description=\"test featuregroup created from numpy matrix\",\n",
    "    descriptive_statistics=False,\n",
    "    feature_correlation=False,\n",
    "    feature_histograms=False,\n",
    "    cluster_analysis=False\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As Numpy arrays do not have an associated schema the resulting feature group will have default column names. A best practice if you are working with numpy is to convert it to a pandas or spark dataframe and specify an explicit schema before you save it to the feature store."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "SQL string for the query created successfully\n",
      "Running sql: SELECT * FROM numpy_test_example_1 against offline feature store\n",
      "+------------------+------------------+-----------------+\n",
      "|             col_0|             col_1|            col_2|\n",
      "+------------------+------------------+-----------------+\n",
      "|25.899999618530273|    13022.44140625|   4593.919921875|\n",
      "|25.219999313354492|  3390.37548828125|  32154.228515625|\n",
      "|25.440000534057617|  13547.4287109375|  22409.615234375|\n",
      "|             26.25|  2248.77587890625|   9372.814453125|\n",
      "|25.709999084472656|1587.0897216796875|2532.163818359375|\n",
      "+------------------+------------------+-----------------+\n",
      "only showing top 5 rows"
     ]
    }
   ],
   "source": [
    "featurestore.get_featuregroup(\"numpy_test_example\", dataframe_type=\"spark\").show(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "SQL string for the query created successfully\n",
      "Running sql: SELECT * FROM numpy_test_example_1 against offline feature store\n",
      "Inserting data into offline feature group numpy_test_example...\n",
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "Inserting data into offline feature group numpy_test_example... [COMPLETE]\n",
      "Insertion into feature group was successful"
     ]
    }
   ],
   "source": [
    "# All insert/create methods in the API supports spark, pandas, and numpy dataframes\n",
    "featurestore.insert_into_featuregroup(\n",
    "    numpy_df, \n",
    "    \"numpy_test_example\",\n",
    "    mode=\"overwrite\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Writing a Python 2D List to the Feature Store"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Registering feature metadata...\n",
      "Registering feature metadata... [COMPLETE]\n",
      "Writing feature data to offline feature group (Hive)...\n",
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "Writing feature data to offline feature group (Hive)... [COMPLETE]\n",
      "Feature group created successfully"
     ]
    }
   ],
   "source": [
    "featurestore.create_featuregroup(\n",
    "    python_df,\n",
    "    \"python_test_example\",\n",
    "    description=\"test featuregroup created from python 2D list\",\n",
    "    descriptive_statistics=False,\n",
    "    feature_correlation=False,\n",
    "    feature_histograms=False,\n",
    "    cluster_analysis=False\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "SQL string for the query created successfully\n",
      "Running sql: SELECT * FROM python_test_example_1 against offline feature store\n",
      "Inserting data into offline feature group python_test_example...\n",
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "Inserting data into offline feature group python_test_example... [COMPLETE]\n",
      "Insertion into feature group was successful"
     ]
    }
   ],
   "source": [
    "# All insert/create methods in the API supports spark, pandas, and numpy dataframes\n",
    "featurestore.insert_into_featuregroup(\n",
    "    python_df, \n",
    "    \"python_test_example\",\n",
    "    mode=\"overwrite\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As python lists do not have an associated schema the resulting feature group will have default column names. A best practice if you are working with python lists is to convert it to a pandas or spark dataframe and specify an explicit schema before you save it to the feature store"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "SQL string for the query created successfully\n",
      "Running sql: SELECT * FROM python_test_example_1 against offline feature store\n",
      "+------------------+------------------+-----------------+\n",
      "|             col_0|             col_1|            col_2|\n",
      "+------------------+------------------+-----------------+\n",
      "|25.899999618530273|    13022.44140625|   4593.919921875|\n",
      "|25.219999313354492|  3390.37548828125|  32154.228515625|\n",
      "|25.440000534057617|  13547.4287109375|  22409.615234375|\n",
      "|             26.25|  2248.77587890625|   9372.814453125|\n",
      "|25.709999084472656|1587.0897216796875|2532.163818359375|\n",
      "+------------------+------------------+-----------------+\n",
      "only showing top 5 rows"
     ]
    }
   ],
   "source": [
    "featurestore.get_featuregroup(\"python_test_example\", dataframe_type=\"spark\").show(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Feature Group Statistics\n",
    "\n",
    "Statistics about a featuregroup can be useful in the stage of feature engineering and when deciding which features to use for training. If statistics have been computed for a feature group, it can be viewed in the Hopsworks Feature Registry UI. \n",
    "\n",
    "This is particularly useful within large organizations where data scientists from different teams can re-use and explore new features by browsing features in the feature store and analyzing the statistics.\n",
    "\n",
    "![Feature Registry Statistics Visualization](./images/fg_stats_1.png \"Feature Registry Statistics Visualization\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you might have notived earlier in this notebook, the `create_featuregroup` method has arguments for configuring the statistics to be computed as data is added. These settings will be saved along with the rest of the meta data about the featuregroup and will be applied when new data is inserted into the featuregroup using the `insert_into_featuregroup` method.\n",
    "\n",
    "You can use the `update_featuregroup_stats()` method to update the settings for the statistics of a feature group and recompute the statistics without inserting any new data. By default it will compute the statistics based on the previous settings, use the project's featurestore and use version 1 of the featuregroup:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "SQL string for the query created successfully\n",
      "Running sql: SELECT * FROM teams_features_1 against offline feature store\n",
      "computing descriptive statistics for : teams_features, version: 1\n",
      "computing feature correlation for: teams_features, version: 1\n",
      "computing feature histograms for: teams_features, version: 1\n",
      "computing cluster analysis for: teams_features, version: 1"
     ]
    }
   ],
   "source": [
    "featurestore.update_featuregroup_stats(\"teams_features\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also be explicitly specify featuregroup details and what statistics to compute, this will also update the settings for future inserts:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "SQL string for the query created successfully\n",
      "Running sql: SELECT * FROM teams_features_1 against offline feature store\n",
      "computing descriptive statistics for : teams_features, version: 1\n",
      "computing feature correlation for: teams_features, version: 1\n",
      "computing feature histograms for: teams_features, version: 1\n",
      "computing cluster analysis for: teams_features, version: 1"
     ]
    }
   ],
   "source": [
    "featurestore.update_featuregroup_stats(\n",
    "    \"teams_features\", \n",
    "    featuregroup_version=1, \n",
    "    featurestore=featurestore.project_featurestore(), \n",
    "    descriptive_statistics=True,\n",
    "    feature_correlation=True, \n",
    "    feature_histograms=True,\n",
    "    cluster_analysis=True,\n",
    "    stat_columns=None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you only want to compute statistics for certain set of columns and exclude surrogate key-columns for example, you can use the optional argument `stat_columns` to specify which columns to include:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "SQL string for the query created successfully\n",
      "Running sql: SELECT * FROM teams_features_1 against offline feature store\n",
      "computing descriptive statistics for : teams_features, version: 1\n",
      "computing feature correlation for: teams_features, version: 1\n",
      "computing feature histograms for: teams_features, version: 1\n",
      "computing cluster analysis for: teams_features, version: 1"
     ]
    }
   ],
   "source": [
    "featurestore.update_featuregroup_stats(\n",
    "    \"teams_features\", \n",
    "    featuregroup_version=1, \n",
    "    featurestore=featurestore.project_featurestore(), \n",
    "    descriptive_statistics=True,\n",
    "    feature_correlation=True, \n",
    "    feature_histograms=True,\n",
    "    cluster_analysis=True,\n",
    "    stat_columns=['team_budget', 'team_position'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training Datasets\n",
    "\n",
    "To group data in the feature store we use three concepts:\n",
    "\n",
    "- Feature\n",
    "- Feature group\n",
    "- Training Dataset\n",
    "\n",
    "Typically during the feature engineering phase of a machine learning project, you compute a set of features for each type of data that you have, these features are naturally grouped into a documented and versioned **feature group**. \n",
    "\n",
    "In practice, it is common that organizations have many different type of datasets that they can extract features from, for example if you are building a recommendation system you might have demographic data about each user as well as user-activity data. \n",
    "\n",
    "When you train a machine learning model, you want to use all features that have predictive power and that the model can learn from. At this point, we can create a training dataset of features from several different feature groups and use that for training. That is the purpose of the training dataset abstraction. \n",
    "\n",
    "Of course you can always just save a group of features anywhere inside your project, e.g as a csv, or .tfrecords file. However, by using the feature store you can create **managed** training datasets. Managed training datasets will show up in the feature registry UI and will automatically be versioned, documented and reproducible. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The training datasets in a project are stored in a top-level dataset called `<ProjectName>_Training_Datasets`, (i.e `hdfs:///Projects/<ProjectName>/<ProjectName>_Training_Datasets`.\n",
    "\n",
    "Once a training dataset have been created you can find it in the featurestore UI in hopsworks under the tab `Training datasets`, from there you can also edit the metadata if necessary. \n",
    "\n",
    "After a training dataset have been created with the necessary metadata you can save the actual data in the training dataset by using the API function `insert_into_training_dataset`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create New Training Dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets create a dataset called `team_position_prediction` by using a set of relevant features from the featurestore. We will combine features from four different feature groups to form this training dataset: `teams_features`, `attendances_features`, `players_features`, `season_scores_features`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Read Features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running sql: use demo_featurestore_admin000_featurestore against offline feature store\n",
      "Logical query plan for getting 12 features from the featurestore created successfully\n",
      "SQL string for the query created successfully\n",
      "Running sql: SELECT team_budget, average_position, sum_player_rating, average_attendance, average_player_worth, sum_player_worth, sum_position, sum_attendance, average_player_rating, team_position, sum_player_age, average_player_age FROM teams_features_1 JOIN season_scores_features_1 JOIN players_features_1 JOIN attendances_features_1 ON teams_features_1.`team_id`=season_scores_features_1.`team_id` AND teams_features_1.`team_id`=players_features_1.`team_id` AND teams_features_1.`team_id`=attendances_features_1.`team_id` against offline feature store"
     ]
    }
   ],
   "source": [
    "features_df = featurestore.get_features(\n",
    "    [\"team_budget\", \"average_attendance\", \"average_player_age\",\n",
    "    \"team_position\", \"sum_attendance\", \n",
    "     \"average_player_rating\", \"average_player_worth\", \"sum_player_age\",\n",
    "     \"sum_player_rating\", \"sum_player_worth\", \"sum_position\", \n",
    "     \"average_position\"\n",
    "    ]\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-----------+----------------+-----------------+------------------+--------------------+----------------+------------+--------------+---------------------+-------------+--------------+------------------+\n",
      "|team_budget|average_position|sum_player_rating|average_attendance|average_player_worth|sum_player_worth|sum_position|sum_attendance|average_player_rating|team_position|sum_player_age|average_player_age|\n",
      "+-----------+----------------+-----------------+------------------+--------------------+----------------+------------+--------------+---------------------+-------------+--------------+------------------+\n",
      "|  12474.419|           34.35|         88129.83|          9405.213|           888.29443|       88829.445|       687.0|     188104.27|             881.2983|            9|        2578.0|             25.78|\n",
      "|  1621.1936|            40.3|         46779.38|          7118.376|           490.94702|       49094.703|       806.0|     142367.52|             467.7938|           17|        2601.0|             26.01|\n",
      "|  16758.066|           55.15|        32269.797|          3271.934|           307.87268|       30787.268|      1103.0|      65438.68|            322.69797|           26|        2565.0|             25.65|\n",
      "|  3966.3591|            57.1|        29779.197|         4074.8047|           298.78235|       29878.234|      1142.0|      81496.09|            297.79196|           27|        2550.0|              25.5|\n",
      "|    7307.94|           28.15|        131123.84|         19595.973|           1435.2465|       143524.64|       563.0|     391919.47|            1311.2384|            6|        2485.0|             24.85|\n",
      "+-----------+----------------+-----------------+------------------+--------------------+----------------+------------+--------------+---------------------+-------------+--------------+------------------+\n",
      "only showing top 5 rows"
     ]
    }
   ],
   "source": [
    "features_df.show(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Get the Latest Version of a Training Dataset (0 if no version exist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0"
     ]
    }
   ],
   "source": [
    "latest_version = featurestore.get_latest_training_dataset_version(\"team_position_prediction\")\n",
    "latest_version"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Save a Training Dataset in TFRecords Format"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can create a training dataset from the dataframe with some extended metadata such as schema (automatically inferred). By default when you create a training dataset it will be in \"tfrecords\" format and statistics will be computed for all features. After the dataset have been created you can view and/or update the metadata about the training dataset from the Hopsworks featurestore UI"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "write feature frame, write_mode: overwrite\n",
      "Training Dataset created successfully"
     ]
    }
   ],
   "source": [
    "featurestore.create_training_dataset(\n",
    "    features_df, \"team_position_prediction\",\n",
    "    descriptive_statistics=False,\n",
    "    feature_correlation=False,\n",
    "    feature_histograms=False,\n",
    "    cluster_analysis=False,\n",
    "    training_dataset_version = latest_version + 1\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can override the default configuration if necessary:\n",
    "\n",
    "Supported data formats are:\n",
    "\n",
    "- csv (written with spark distributed)\n",
    "- tsv (written with spark distributed)\n",
    "- parquet (written with spark distributed)\n",
    "- tfrecords (written with spark distributed)\n",
    "- avro (written with spark distributed)\n",
    "- orc (written with spark distributed)\n",
    "- hdf5 (written with single-machine, must fit into memory)\n",
    "- npy (written with single-machine, must fit into memory)\n",
    "- petastorm (written with spark distributed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Save a Training Dataset in  CSV format"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training Dataset created successfully"
     ]
    }
   ],
   "source": [
    "featurestore.create_training_dataset(\n",
    "    features_df, \"team_position_prediction_csv\",\n",
    "    description=\"a dataset with features for football teams, used for training a model to predict league-position\",\n",
    "    featurestore=featurestore.project_featurestore(),\n",
    "    data_format=\"csv\",\n",
    "    training_dataset_version=featurestore.get_latest_training_dataset_version(\"team_position_prediction_csv\") + 1,\n",
    "    descriptive_statistics=False,\n",
    "    feature_correlation=False,\n",
    "    feature_histograms=False,\n",
    "    cluster_analysis=False,\n",
    "    stat_columns=None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Save a Training Dataset in  TSV format"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training Dataset created successfully"
     ]
    }
   ],
   "source": [
    "featurestore.create_training_dataset(\n",
    "    features_df, \"team_position_prediction_tsv\",\n",
    "    description=\"a dataset with features for football teams, used for training a model to predict league-position\",\n",
    "    featurestore=featurestore.project_featurestore(),\n",
    "    data_format=\"tsv\",\n",
    "    training_dataset_version=featurestore.get_latest_training_dataset_version(\"team_position_prediction_tsv\") + 1,\n",
    "    descriptive_statistics=False,\n",
    "    feature_correlation=False,\n",
    "    feature_histograms=False,\n",
    "    cluster_analysis=False,\n",
    "    stat_columns=None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Save a Training Dataset in Parquet format"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training Dataset created successfully"
     ]
    }
   ],
   "source": [
    "featurestore.create_training_dataset(\n",
    "    features_df, \"team_position_prediction_parquet\",\n",
    "    description=\"a dataset with features for football teams, used for training a model to predict league-position\",\n",
    "    featurestore=featurestore.project_featurestore(),\n",
    "    data_format=\"parquet\",\n",
    "    training_dataset_version=featurestore.get_latest_training_dataset_version(\"team_position_prediction_parquet\") + 1,\n",
    "    descriptive_statistics=False,\n",
    "    feature_correlation=False,\n",
    "    feature_histograms=False,\n",
    "    cluster_analysis=False,\n",
    "    stat_columns=None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Save a Training Dataset in ORC format"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training Dataset created successfully"
     ]
    }
   ],
   "source": [
    "featurestore.create_training_dataset(\n",
    "    features_df, \"team_position_prediction_orc\",\n",
    "    description=\"a dataset with features for football teams, used for training a model to predict league-position\",\n",
    "    featurestore=featurestore.project_featurestore(),\n",
    "    data_format=\"orc\",\n",
    "    training_dataset_version=featurestore.get_latest_training_dataset_version(\"team_position_prediction_orc\") + 1,\n",
    "    descriptive_statistics=False,\n",
    "    feature_correlation=False,\n",
    "    feature_histograms=False,\n",
    "    cluster_analysis=False,\n",
    "    stat_columns=None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Save a Training Dataset in avro format"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training Dataset created successfully"
     ]
    }
   ],
   "source": [
    "featurestore.create_training_dataset(\n",
    "    features_df, \"team_position_prediction_avro\",\n",
    "    description=\"a dataset with features for football teams, used for training a model to predict league-position\",\n",
    "    featurestore=featurestore.project_featurestore(),\n",
    "    data_format=\"avro\",\n",
    "    training_dataset_version=featurestore.get_latest_training_dataset_version(\"team_position_prediction_avro\") + 1,\n",
    "    descriptive_statistics=False,\n",
    "    feature_correlation=False,\n",
    "    feature_histograms=False,\n",
    "    cluster_analysis=False,\n",
    "    stat_columns=None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Save a Training Dataset in HDF5 format"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training Dataset created successfully\n",
      "/srv/hops/anaconda/anaconda/envs/demo_featurestore_admin000/lib/python3.6/site-packages/hops/featurestore_impl/featureframes/FeatureFrame.py:464: H5pyDeprecationWarning: The default file mode will change to 'r' (read-only) in h5py 3.0. To suppress this warning, pass the mode you need to h5py.File(), or set the global default h5.get_config().default_file_mode, or set the environment variable H5PY_DEFAULT_READONLY=1. Available modes are: 'r', 'r+', 'w', 'w-'/'x', 'a'. See the docs for details.\n",
      "  hdf5_file = h5py.File(tf)"
     ]
    }
   ],
   "source": [
    "featurestore.create_training_dataset(\n",
    "    features_df, \"team_position_prediction_hdf5\",\n",
    "    description=\"a dataset with features for football teams, used for training a model to predict league-position\",\n",
    "    featurestore=featurestore.project_featurestore(),\n",
    "    data_format=\"hdf5\",\n",
    "    training_dataset_version=featurestore.get_latest_training_dataset_version(\"team_position_prediction_hdf5\") + 1,\n",
    "    descriptive_statistics=False,\n",
    "    feature_correlation=False,\n",
    "    feature_histograms=False,\n",
    "    cluster_analysis=False,\n",
    "    stat_columns=None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Save a Training Dataset in  .npy format"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training Dataset created successfully"
     ]
    }
   ],
   "source": [
    "featurestore.create_training_dataset(\n",
    "    features_df, \"team_position_prediction_npy\",\n",
    "    description=\"a dataset with features for football teams, used for training a model to predict league-position\",\n",
    "    featurestore=featurestore.project_featurestore(),\n",
    "    data_format=\"npy\",\n",
    "    training_dataset_version=featurestore.get_latest_training_dataset_version(\"team_position_prediction_npy\") + 1,\n",
    "    descriptive_statistics=False,\n",
    "    feature_correlation=False,\n",
    "    feature_histograms=False,\n",
    "    cluster_analysis=False,\n",
    "    stat_columns=None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Save a Training Dataset in petastorm format\n",
    "\n",
    "Petastorm requires an explicit **Unischema** that can be pased to `create_training_dataset` with the optional argument `petastorm_args` that contain a dict of petastorm arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "root\n",
      " |-- team_budget: float (nullable = true)\n",
      " |-- average_position: float (nullable = true)\n",
      " |-- sum_player_rating: float (nullable = true)\n",
      " |-- average_attendance: float (nullable = true)\n",
      " |-- average_player_worth: float (nullable = true)\n",
      " |-- sum_player_worth: float (nullable = true)\n",
      " |-- sum_position: float (nullable = true)\n",
      " |-- sum_attendance: float (nullable = true)\n",
      " |-- average_player_rating: float (nullable = true)\n",
      " |-- team_position: integer (nullable = true)\n",
      " |-- sum_player_age: float (nullable = true)\n",
      " |-- average_player_age: float (nullable = true)"
     ]
    }
   ],
   "source": [
    "from petastorm.unischema import dict_to_spark_row, Unischema, UnischemaField\n",
    "from petastorm.codecs import ScalarCodec, CompressedImageCodec, NdarrayCodec\n",
    "from pyspark.sql.types import StructType, StructField, IntegerType, FloatType\n",
    "import numpy as np\n",
    "features_df.printSchema()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [],
   "source": [
    "PetastormSchema = Unischema('team_position_prediction_petastorm_schema', [\n",
    "    UnischemaField('team_budget', np.float32, (), ScalarCodec(FloatType()), False),\n",
    "    UnischemaField('average_position', np.float32, (), ScalarCodec(FloatType()), False),\n",
    "    UnischemaField('sum_player_rating', np.float32, (), ScalarCodec(FloatType()), False),\n",
    "    UnischemaField('average_attendance', np.float32, (), ScalarCodec(FloatType()), False),\n",
    "    UnischemaField('average_player_worth', np.float32, (), ScalarCodec(FloatType()), False),\n",
    "    UnischemaField('sum_player_worth', np.float32, (), ScalarCodec(FloatType()), False),\n",
    "    UnischemaField('sum_position', np.float32, (), ScalarCodec(FloatType()), False),\n",
    "    UnischemaField('average_player_rating', np.float32, (), ScalarCodec(FloatType()), False),\n",
    "    UnischemaField('team_position', np.int32, (), ScalarCodec(IntegerType()), False),\n",
    "    UnischemaField('sum_player_age', np.float32, (), ScalarCodec(FloatType()), False),\n",
    "    UnischemaField('average_player_age', np.float32, (), ScalarCodec(FloatType()), False),\n",
    "])\n",
    "\n",
    "petastorm_args = {\n",
    "    \"schema\": PetastormSchema\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training Dataset created successfully"
     ]
    }
   ],
   "source": [
    "featurestore.create_training_dataset(\n",
    "    features_df, \"team_position_prediction_petastorm\",\n",
    "    description=\"a dataset with features for football teams, used for training a model to predict league-position\",\n",
    "    featurestore=featurestore.project_featurestore(),\n",
    "    data_format=\"petastorm\",\n",
    "    training_dataset_version=featurestore.get_latest_training_dataset_version(\"team_position_prediction_petastorm\") + 1,\n",
    "    descriptive_statistics=False,\n",
    "    feature_correlation=False,\n",
    "    feature_histograms=False,\n",
    "    cluster_analysis=False,\n",
    "    stat_columns=None,\n",
    "    petastorm_args=petastorm_args\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Create a New Version of A Training Dataset\n",
    "\n",
    "To create a new version, simply use the `create_training_dataset` method and specify the version argument:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "write feature frame, write_mode: overwrite\n",
      "Training Dataset created successfully"
     ]
    }
   ],
   "source": [
    "featurestore.create_training_dataset(\n",
    "    features_df, \"team_position_prediction\",\n",
    "    training_dataset_version=featurestore.get_latest_training_dataset_version(\"team_position_prediction\") + 1,\n",
    "    descriptive_statistics=False,\n",
    "    feature_correlation=False,\n",
    "    feature_histograms=False,\n",
    "    cluster_analysis=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Inserting Into an Existing Training Dataset\n",
    "\n",
    "Once a dataset have been created, its metadata is browsable in the featurestore registry in the Hopsworks UI. If you don't want to create a new training dataset but just overwrite or insert new data into an existing training dataset, you can use the API function `insert_into_training_dataset`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "insert_into_training_dataset\n",
      "Writing Feature Frame, data format: csv\n",
      "Insertion into training dataset was successful"
     ]
    }
   ],
   "source": [
    "featurestore.insert_into_training_dataset(\n",
    "    features_df, \n",
    "    \"team_position_prediction_csv\",\n",
    "    descriptive_statistics=False,\n",
    "    feature_correlation=False,\n",
    "    feature_histograms=False,\n",
    "    cluster_analysis=False,\n",
    "    training_dataset_version=featurestore.get_latest_training_dataset_version(\"team_position_prediction_csv\")\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By default the `insert_into_training_dataset` will use the project's featurestore, overwrite semantics, version 1 of the training dataset, and update the training dataset statistics, this configuration can be overridden.\n",
    "\n",
    "**Note**: \"append\" write mode is not supported for training datasets stored in tfrecords format, only \"overwrite\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "insert_into_training_dataset\n",
      "Writing Feature Frame, data format: csv\n",
      "Insertion into training dataset was successful"
     ]
    }
   ],
   "source": [
    "featurestore.insert_into_training_dataset(\n",
    "    features_df,\n",
    "    \"team_position_prediction_csv\",\n",
    "    featurestore=featurestore.project_featurestore(),\n",
    "    descriptive_statistics=False,\n",
    "    feature_correlation=False,\n",
    "    feature_histograms=False,\n",
    "    cluster_analysis=False,\n",
    "    stat_columns=None,\n",
    "    write_mode=\"overwrite\",\n",
    "    training_dataset_version=featurestore.get_latest_training_dataset_version(\"team_position_prediction_csv\")\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Get Training Dataset Path\n",
    "\n",
    "After a **managed dataset** have been created, it is easy to share it and re-use it for training various models. For example if the dataset have been materialized in tf-records format you can call the method `get_training_dataset_path(training_dataset)` to get the HDFS path and read it directly in your tensorflow code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'hdfs://172.31.22.2:8020/Projects/demo_featurestore_admin000/demo_featurestore_admin000_Training_Datasets/team_position_prediction_csv_1/team_position_prediction_csv'"
     ]
    }
   ],
   "source": [
    "featurestore.get_training_dataset_path(\"team_position_prediction_csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'hdfs://172.31.22.2:8020/Projects/demo_featurestore_admin000/demo_featurestore_admin000_Training_Datasets/team_position_prediction_hdf5_1/team_position_prediction_hdf5.hdf5'"
     ]
    }
   ],
   "source": [
    "featurestore.get_training_dataset_path(\"team_position_prediction_hdf5\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By default the library will look for the training dataset in the project's featurestore and use version 1, but this can be overriden if required:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'hdfs://172.31.22.2:8020/Projects/demo_featurestore_admin000/demo_featurestore_admin000_Training_Datasets/team_position_prediction_csv_1/team_position_prediction_csv'"
     ]
    }
   ],
   "source": [
    "featurestore.get_training_dataset_path(\n",
    "    \"team_position_prediction_csv\", \n",
    "    featurestore=featurestore.project_featurestore(),\n",
    "    training_dataset_version=featurestore.get_latest_training_dataset_version(\"team_position_prediction_csv\")\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### External Training Datasets\n",
    "\n",
    "By default, training datasets in the Feature Store are stored in HopsFS. However, it is also possible to store datasets on S3 and just manage the metadata from Hopsworks Feature Store. \n",
    "\n",
    "To do this, configure an s3 connector for your feature store, e.g with name `my_s3_connector`, then you can save a training dataset to s3 by specifying the s3_connector name in the `sink` argument to `create_training_dataset`:\n",
    "\n",
    "```python\n",
    "from hops import featurestore\n",
    "featurestore.create_training_dataset(sparkDf, training_datset_name, sink=\"my_s3_connector\")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Update Training Dataset Stats\n",
    "\n",
    "The API for updating training dataset stats is the same as for updating feature group stats:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "computing descriptive statistics for : team_position_prediction, version: 1\n",
      "computing feature correlation for: team_position_prediction, version: 1\n",
      "computing feature histograms for: team_position_prediction, version: 1\n",
      "computing cluster analysis for: team_position_prediction, version: 1"
     ]
    }
   ],
   "source": [
    "featurestore.update_training_dataset_stats(\"team_position_prediction\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Optional arguments:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "computing descriptive statistics for : team_position_prediction, version: 1\n",
      "computing feature correlation for: team_position_prediction, version: 1\n",
      "computing feature histograms for: team_position_prediction, version: 1\n",
      "computing cluster analysis for: team_position_prediction, version: 1"
     ]
    }
   ],
   "source": [
    "featurestore.update_training_dataset_stats(\n",
    "    \"team_position_prediction\", \n",
    "    training_dataset_version=1, \n",
    "    featurestore=featurestore.project_featurestore(), \n",
    "    descriptive_statistics=True,\n",
    "    feature_correlation=True, \n",
    "    feature_histograms=True,\n",
    "    cluster_analysis=True,\n",
    "    stat_columns=None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Training Dataset Visualization\n",
    "\n",
    "Just as for featuregroups, the training dataset statistics can be visualized in the Jupyter notebook in `%%local`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Feature Distributions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Remember to add %%matplotlib inline when doing visualizations in Jupyter notebooks\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x864 with 12 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%local\n",
    "featurestore.visualize_training_dataset_distributions(\"team_position_prediction\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also override default parameters and set plotting configuration:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Remember to add %%matplotlib inline when doing visualizations in Jupyter notebooks\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x648 with 12 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%local\n",
    "featurestore.visualize_training_dataset_distributions(\"team_position_prediction\", \n",
    "                                                  featurestore=featurestore.project_featurestore(), \n",
    "                                                  training_dataset_version=1, \n",
    "                                                  figsize=(12, 9),\n",
    "                                                  color='lightblue', \n",
    "                                                  log=False, \n",
    "                                                  align=\"center\", \n",
    "                                                  plot=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also compute the figure in the spark kernel (don't have to use `%%local` then) and save it to HDFS for later viewing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Started copying local path team_position_prediction_distributions.png to hdfs path hdfs://172.31.22.2:8020/Projects/demo_featurestore_admin000/Resources//team_position_prediction_distributions.png\n",
      "\n",
      "Finished copying"
     ]
    }
   ],
   "source": [
    "from hops import hdfs\n",
    "fig = featurestore.visualize_training_dataset_distributions(\"team_position_prediction\", plot=False)\n",
    "fig.savefig(\"team_position_prediction_distributions.png\")\n",
    "hdfs.copy_to_hdfs(\"team_position_prediction_distributions.png\", \"Resources/\", overwrite=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Feature Correlations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Remember to add %%matplotlib inline when doing visualizations in Jupyter notebooks\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x864 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%local\n",
    "featurestore.visualize_training_dataset_correlations(\"team_position_prediction\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also override default parameters and set plotting configuration:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Remember to add %%matplotlib inline when doing visualizations in Jupyter notebooks\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%local\n",
    "featurestore.visualize_training_dataset_correlations(\"team_position_prediction\", \n",
    "                                                 featurestore=None, \n",
    "                                                 training_dataset_version=1, \n",
    "                                                 figsize=(8,6),\n",
    "                                                 cmap=\"coolwarm\", \n",
    "                                                 annot=True, \n",
    "                                                 fmt=\".2f\", \n",
    "                                                 linewidths=.05, \n",
    "                                                 plot=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also compute the figure in the spark kernel (don't have to use `%%local` then) and save it to HDFS for later viewing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Started copying local path team_position_prediction_correlations.png to hdfs path hdfs://172.31.22.2:8020/Projects/demo_featurestore_admin000/Resources//team_position_prediction_correlations.png\n",
      "\n",
      "Finished copying"
     ]
    }
   ],
   "source": [
    "from hops import hdfs\n",
    "fig = featurestore.visualize_training_dataset_correlations(\"team_position_prediction\", plot=False)\n",
    "fig.savefig(\"team_position_prediction_correlations.png\")\n",
    "hdfs.copy_to_hdfs(\"team_position_prediction_correlations.png\", \"Resources/\", overwrite=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Feature Clusters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Remember to add %%matplotlib inline when doing visualizations in Jupyter notebooks\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x864 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%local\n",
    "featurestore.visualize_training_dataset_clusters(\"team_position_prediction\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also override default parameters and set plotting configuration:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Remember to add %%matplotlib inline when doing visualizations in Jupyter notebooks\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%local\n",
    "featurestore.visualize_training_dataset_clusters(\"team_position_prediction\", \n",
    "                                featurestore=None, \n",
    "                                training_dataset_version=1, \n",
    "                                figsize=(8,6),\n",
    "                                plot=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also compute the figure in the spark kernel (don't have to use `%%local` then) and save it to HDFS for later viewing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Started copying local path team_position_prediction_clusters.png to hdfs path hdfs://172.31.22.2:8020/Projects/demo_featurestore_admin000/Resources//team_position_prediction_clusters.png\n",
      "\n",
      "Finished copying"
     ]
    }
   ],
   "source": [
    "from hops import hdfs\n",
    "fig = featurestore.visualize_training_dataset_clusters(\"team_position_prediction\", plot=False)\n",
    "fig.savefig(\"team_position_prediction_clusters.png\")\n",
    "hdfs.copy_to_hdfs(\"team_position_prediction_clusters.png\", \"Resources/\", overwrite=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Descriptive Stats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/srv/hops/anaconda/anaconda/envs/demo_featurestore_admin000/lib/python3.6/site-packages/autovizwidget/widget/utils.py:50: FutureWarning:\n",
      "\n",
      "A future version of pandas will default to `skipna=True`. To silence this warning, pass `skipna=True|False` explicitly.\n",
      "\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "cefed62c9c5841478d9ad93db618973f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(HBox(children=(HTML(value='Type:'), Button(description='Table', layout=Layout(width='70px'), st…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9400d60bf68749e4bf54730c98291bbc",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%local\n",
    "desc_stats_df = featurestore.visualize_training_dataset_descriptive_stats(\"team_position_prediction\")\n",
    "desc_stats_df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since descriptive stats is just a pandas table and not a matplotlib figure it does not need a DISPLAY to work, so you can run it from the spark driver or executor as well:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   metric  team_budget  ...  sum_player_rating  average_attendance\n",
      "0  stddev    5238.9430  ...         118708.750          14232.3090\n",
      "1     min     760.8729  ...          15096.327           1038.5237\n",
      "2    mean    8723.2920  ...          71738.375           8669.3940\n",
      "3   count      50.0000  ...             50.000             50.0000\n",
      "4     max   21319.5330  ...         719186.300          92301.0860\n",
      "\n",
      "[5 rows x 13 columns]"
     ]
    }
   ],
   "source": [
    "desc_stats_df = featurestore.visualize_training_dataset_descriptive_stats(\"team_position_prediction\")\n",
    "desc_stats_df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Read Training Dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Read Training Dataset into a Spark Dataframe\n",
    "\n",
    "Typically training datasets are served into deep learning frameworks such as pytorch or tensorflow. However, training datasets can also be read into spark dataframes using the api method `get_training_dataset()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-----------+----------------+-----------------+------------------+--------------------+----------------+------------+--------------+---------------------+-------------+--------------+------------------+\n",
      "|team_budget|average_position|sum_player_rating|average_attendance|average_player_worth|sum_player_worth|sum_position|sum_attendance|average_player_rating|team_position|sum_player_age|average_player_age|\n",
      "+-----------+----------------+-----------------+------------------+--------------------+----------------+------------+--------------+---------------------+-------------+--------------+------------------+\n",
      "|  12474.419|           34.35|         88129.83|          9405.213|           888.29443|       88829.445|       687.0|     188104.27|             881.2983|            9|        2578.0|             25.78|\n",
      "|  1621.1936|            40.3|         46779.38|          7118.376|           490.94702|       49094.703|       806.0|     142367.52|             467.7938|           17|        2601.0|             26.01|\n",
      "|  16758.066|           55.15|        32269.797|          3271.934|           307.87268|       30787.268|      1103.0|      65438.68|            322.69797|           26|        2565.0|             25.65|\n",
      "|  3966.3591|            57.1|        29779.197|         4074.8047|           298.78235|       29878.234|      1142.0|      81496.09|            297.79196|           27|        2550.0|              25.5|\n",
      "|    7307.94|           28.15|        131123.84|         19595.973|           1435.2465|       143524.64|       563.0|     391919.47|            1311.2384|            6|        2485.0|             24.85|\n",
      "+-----------+----------------+-----------------+------------------+--------------------+----------------+------------+--------------+---------------------+-------------+--------------+------------------+\n",
      "only showing top 5 rows"
     ]
    }
   ],
   "source": [
    "featurestore.get_training_dataset(\"team_position_prediction_csv\").show(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By default the library will read the training dataset from the project's feature store, use version 1 and return the data in a spark dataframe. This can be overriden:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  team_budget average_position  ... sum_player_age average_player_age\n",
      "0   12474.419            34.35  ...         2578.0              25.78\n",
      "1   1621.1936             40.3  ...         2601.0              26.01\n",
      "2   16758.066            55.15  ...         2565.0              25.65\n",
      "3   3966.3591             57.1  ...         2550.0               25.5\n",
      "4     7307.94            28.15  ...         2485.0              24.85\n",
      "\n",
      "[5 rows x 12 columns]"
     ]
    }
   ],
   "source": [
    "featurestore.get_training_dataset(\"team_position_prediction_csv\",\n",
    "                                  featurestore=featurestore.project_featurestore(),\n",
    "                                  training_dataset_version=1,\n",
    "                                  dataframe_type=\"pandas\"\n",
    "                                 ).head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-----------+----------------+-----------------+------------------+--------------------+----------------+------------+--------------+---------------------+-------------+--------------+------------------+\n",
      "|team_budget|average_position|sum_player_rating|average_attendance|average_player_worth|sum_player_worth|sum_position|sum_attendance|average_player_rating|team_position|sum_player_age|average_player_age|\n",
      "+-----------+----------------+-----------------+------------------+--------------------+----------------+------------+--------------+---------------------+-------------+--------------+------------------+\n",
      "|  12474.419|           34.35|         88129.83|          9405.213|           888.29443|       88829.445|       687.0|     188104.27|             881.2983|            9|        2578.0|             25.78|\n",
      "|  1621.1936|            40.3|         46779.38|          7118.376|           490.94702|       49094.703|       806.0|     142367.52|             467.7938|           17|        2601.0|             26.01|\n",
      "|  16758.066|           55.15|        32269.797|          3271.934|           307.87268|       30787.268|      1103.0|      65438.68|            322.69797|           26|        2565.0|             25.65|\n",
      "|  3966.3591|            57.1|        29779.197|         4074.8047|           298.78235|       29878.234|      1142.0|      81496.09|            297.79196|           27|        2550.0|              25.5|\n",
      "|    7307.94|           28.15|        131123.84|         19595.973|           1435.2465|       143524.64|       563.0|     391919.47|            1311.2384|            6|        2485.0|             24.85|\n",
      "+-----------+----------------+-----------------+------------------+--------------------+----------------+------------+--------------+---------------------+-------------+--------------+------------------+\n",
      "only showing top 5 rows"
     ]
    }
   ],
   "source": [
    "featurestore.get_training_dataset(\"team_position_prediction_petastorm\",\n",
    "                                  dataframe_type=\"spark\").show(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Get Featurestore Metadata\n",
    "To explore the contents of the featurestore we recommend using the featurestore page in the Hopsworks UI but you can also get the metadata programmatically from the REST API"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Update Metadata Cache"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<hops.featurestore_impl.dao.common.featurestore_metadata.FeaturestoreMetadata object at 0x7f0b58138630>"
     ]
    }
   ],
   "source": [
    "featurestore.get_featurestore_metadata(update_cache=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List all Feature Stores Accessible In the Project"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['demo_featurestore_admin000_featurestore']"
     ]
    }
   ],
   "source": [
    "featurestore.get_project_featurestores()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List all Feature Groups in a Feature Store"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['teams_features_1', 'games_features_on_demand_tour_1', 'players_features_1', 'games_features_hudi_tour_1', 'games_features_1', 'attendances_features_1', 'season_scores_features_1', 'test_response_1', 'numpy_test_example_1', 'pandas_test_example_1', 'teams_features_spanish_2', 'teams_features_spanish_1', 'python_test_example_1', 'games_features_on_demand_1', 'teams_features_spanish_3', 'hive_fs_sync_example_1', 'games_features_partitioned_1', 'games_features_double_partitioned_1', 'players_features_on_demand_1']"
     ]
    }
   ],
   "source": [
    "featurestore.get_featuregroups()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By default `get_featuregroups()` will use the project's feature store, but this can also be specified with the optional argument featurestore"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['teams_features_1', 'games_features_on_demand_tour_1', 'players_features_1', 'games_features_hudi_tour_1', 'games_features_1', 'attendances_features_1', 'season_scores_features_1', 'test_response_1', 'numpy_test_example_1', 'pandas_test_example_1', 'teams_features_spanish_2', 'teams_features_spanish_1', 'python_test_example_1', 'games_features_on_demand_1', 'teams_features_spanish_3', 'hive_fs_sync_example_1', 'games_features_partitioned_1', 'games_features_double_partitioned_1', 'players_features_on_demand_1']"
     ]
    }
   ],
   "source": [
    "featurestore.get_featuregroups(featurestore=featurestore.project_featurestore())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List all Features in a Feature Store"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['team_budget', 'team_id', 'team_position', 'average_player_age', 'average_player_rating', 'average_player_worth', 'sum_player_age', 'sum_player_rating', 'sum_player_worth', 'team_id', 'away_team_id', 'home_team_id', '_hoodie_commit_seqno', '_hoodie_commit_time', '_hoodie_file_name', '_hoodie_partition_path', '_hoodie_record_key', 'score', 'away_team_id', 'home_team_id', 'score', 'average_attendance', 'sum_attendance', 'team_id', 'average_position', 'sum_position', 'team_id', 'area_id', 'avg_house_age', 'avg_house_size', 'avg_house_worth', 'sum_house_age', 'sum_house_size', 'sum_house_worth', 'col_0', 'col_1', 'col_2', 'average_attendance_test', 'average_player_age_test', 'team_budget_test', 'equipo_id', 'equipo_posicion', 'equipo_presupuesto', 'equipo_id', 'equipo_posicion', 'equipo_presupuesto', 'col_0', 'col_1', 'col_2', 'equipo_id', 'equipo_posicion', 'equipo_presupuesto', 'equipo_id', 'equipo_posicion', 'equipo_presupuesto', 'away_team_id', 'home_team_id', 'score', 'away_team_id', 'home_team_id', 'score']"
     ]
    }
   ],
   "source": [
    "featurestore.get_features_list()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By default get_features_list() will use the project's feature store, but this can also be specified with the optional argument featurestore"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['team_budget', 'team_id', 'team_position', 'average_player_age', 'average_player_rating', 'average_player_worth', 'sum_player_age', 'sum_player_rating', 'sum_player_worth', 'team_id', 'away_team_id', 'home_team_id', '_hoodie_commit_seqno', '_hoodie_commit_time', '_hoodie_file_name', '_hoodie_partition_path', '_hoodie_record_key', 'score', 'away_team_id', 'home_team_id', 'score', 'average_attendance', 'sum_attendance', 'team_id', 'average_position', 'sum_position', 'team_id', 'area_id', 'avg_house_age', 'avg_house_size', 'avg_house_worth', 'sum_house_age', 'sum_house_size', 'sum_house_worth', 'col_0', 'col_1', 'col_2', 'average_attendance_test', 'average_player_age_test', 'team_budget_test', 'equipo_id', 'equipo_posicion', 'equipo_presupuesto', 'equipo_id', 'equipo_posicion', 'equipo_presupuesto', 'col_0', 'col_1', 'col_2', 'equipo_id', 'equipo_posicion', 'equipo_presupuesto', 'equipo_id', 'equipo_posicion', 'equipo_presupuesto', 'away_team_id', 'home_team_id', 'score', 'away_team_id', 'home_team_id', 'score']"
     ]
    }
   ],
   "source": [
    "featurestore.get_features_list(featurestore=featurestore.project_featurestore())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List all Training Datasets in a Feature Store"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['tour_training_dataset_test_1', 'team_position_prediction_1', 'team_position_prediction_csv_1', 'team_position_prediction_tsv_1', 'team_position_prediction_parquet_1', 'team_position_prediction_orc_1', 'team_position_prediction_avro_1', 'team_position_prediction_hdf5_1', 'team_position_prediction_npy_1', 'team_position_prediction_petastorm_1', 'team_position_prediction_2']"
     ]
    }
   ],
   "source": [
    "featurestore.get_training_datasets()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By default `get_training_datasets()` will use the project's feature store, but this can also be specified with the optional argument featurestore"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['tour_training_dataset_test_1', 'team_position_prediction_1', 'team_position_prediction_csv_1', 'team_position_prediction_tsv_1', 'team_position_prediction_parquet_1', 'team_position_prediction_orc_1', 'team_position_prediction_avro_1', 'team_position_prediction_hdf5_1', 'team_position_prediction_npy_1', 'team_position_prediction_petastorm_1', 'team_position_prediction_2']"
     ]
    }
   ],
   "source": [
    "featurestore.get_training_datasets(featurestore=featurestore.project_featurestore())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List all Storage Connectors in a Feature Store"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('demo_featurestore_admin000_featurestore', 'JDBC'), ('demo_featurestore_admin000', 'JDBC'), ('demo_featurestore_admin000_meb1_onlinefeaturestore', 'JDBC'), ('demo_featurestore_admin000_Training_Datasets', 'HOPSFS')]"
     ]
    }
   ],
   "source": [
    "featurestore.get_storage_connectors()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By default `get_storage_connectors()` will use the project's feature store, but this can also be specified with the optional argument featurestore"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('demo_featurestore_admin000_featurestore', 'JDBC'), ('demo_featurestore_admin000', 'JDBC'), ('demo_featurestore_admin000_meb1_onlinefeaturestore', 'JDBC'), ('demo_featurestore_admin000_Training_Datasets', 'HOPSFS')]"
     ]
    }
   ],
   "source": [
    "featurestore.get_storage_connectors(featurestore=featurestore.project_featurestore())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Get All Metadata (Features, Feature groups, Training Datasets) for a Feature Store"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<hops.featurestore_impl.dao.common.featurestore_metadata.FeaturestoreMetadata object at 0x7f0b58138630>"
     ]
    }
   ],
   "source": [
    "featurestore.get_featurestore_metadata()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By default `get_featurestore_metadata` will use the project's feature store, but this can also be specified with the optional argument featurestore"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<hops.featurestore_impl.dao.common.featurestore_metadata.FeaturestoreMetadata object at 0x7f0b58138630>"
     ]
    }
   ],
   "source": [
    "featurestore.get_featurestore_metadata(featurestore=featurestore.project_featurestore())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Attach Metadata to a Feature Group"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The feature store enables users to attach a dictionary of metadata to a feature group. It is only supported for CachedFeatureGroups."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "featurestore.add_metadata(\"teams_features\", {\"attr1\" : \"attr1 value\", \"attr2\" : \"attr2 value\"})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Get All Metadata associated to a Feature Group"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "featurestore.get_metadata(\"teams_features\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Get the metadata by their keys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "featurestore.get_metadata(\"teams_features\", [\"attr1\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Remove metadata attached to a Feature Group"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "featurestore.remove_metadata(\"teams_features\", [\"attr1\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## From Raw Data to Features to Training Dataset to Model\n",
    "\n",
    "Once a training dataset have been materialized, we can use it to train a model. The featurestore API makes the integration with libraries such as Tensorflow simple. In this section we will train an example model using the training dataset `team_position_prediction` that we created earlier. We will use the column **\"team_position\"** as the target to predict."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Get TFRecords Schema from a Spark Dataframe\n",
    "\n",
    "This utility method can be used when parsing training datasets in the tfrecords format. Note that this method will try to infer the tensorflow example schema from the schema of the spark dataframe. If you want full control of the tf-record schema you should define it manually."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'team_budget': FixedLenFeature(shape=[], dtype=tf.float32, default_value=None), 'average_position': FixedLenFeature(shape=[], dtype=tf.float32, default_value=None), 'sum_player_rating': FixedLenFeature(shape=[], dtype=tf.float32, default_value=None), 'average_attendance': FixedLenFeature(shape=[], dtype=tf.float32, default_value=None), 'average_player_worth': FixedLenFeature(shape=[], dtype=tf.float32, default_value=None), 'sum_player_worth': FixedLenFeature(shape=[], dtype=tf.float32, default_value=None), 'sum_position': FixedLenFeature(shape=[], dtype=tf.float32, default_value=None), 'sum_attendance': FixedLenFeature(shape=[], dtype=tf.float32, default_value=None), 'average_player_rating': FixedLenFeature(shape=[], dtype=tf.float32, default_value=None), 'team_position': FixedLenFeature(shape=[], dtype=tf.int64, default_value=None), 'sum_player_age': FixedLenFeature(shape=[], dtype=tf.float32, default_value=None), 'average_player_age': FixedLenFeature(shape=[], dtype=tf.float32, default_value=None)}"
     ]
    }
   ],
   "source": [
    "featurestore.get_dataframe_tf_record_schema(features_df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Get TFRecords Schema from a Training Dataset\n",
    "\n",
    "When a training dataset is saved in the tfrecords format, the tfrecord schema is stored together with the training dataset in a file called `tf_record_schema.txt`. This schema can be retrieved when the tfrecords need to be parsed. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'team_budget': FixedLenFeature(shape=[], dtype=tf.float32, default_value=None), 'average_position': FixedLenFeature(shape=[], dtype=tf.float32, default_value=None), 'sum_player_rating': FixedLenFeature(shape=[], dtype=tf.float32, default_value=None), 'average_attendance': FixedLenFeature(shape=[], dtype=tf.float32, default_value=None), 'average_player_worth': FixedLenFeature(shape=[], dtype=tf.float32, default_value=None), 'sum_player_worth': FixedLenFeature(shape=[], dtype=tf.float32, default_value=None), 'sum_position': FixedLenFeature(shape=[], dtype=tf.float32, default_value=None), 'sum_attendance': FixedLenFeature(shape=[], dtype=tf.float32, default_value=None), 'average_player_rating': FixedLenFeature(shape=[], dtype=tf.float32, default_value=None), 'team_position': FixedLenFeature(shape=[], dtype=tf.int64, default_value=None), 'sum_player_age': FixedLenFeature(shape=[], dtype=tf.float32, default_value=None), 'average_player_age': FixedLenFeature(shape=[], dtype=tf.float32, default_value=None)}"
     ]
    }
   ],
   "source": [
    "featurestore.get_training_dataset_tf_record_schema(\"team_position_prediction\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By default `get_training_dataset_tf_record_schema` will use the project's feature store and version 1 of the feature grup, this can be overriden if necessary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'team_budget': FixedLenFeature(shape=[], dtype=tf.float32, default_value=None), 'average_position': FixedLenFeature(shape=[], dtype=tf.float32, default_value=None), 'sum_player_rating': FixedLenFeature(shape=[], dtype=tf.float32, default_value=None), 'average_attendance': FixedLenFeature(shape=[], dtype=tf.float32, default_value=None), 'average_player_worth': FixedLenFeature(shape=[], dtype=tf.float32, default_value=None), 'sum_player_worth': FixedLenFeature(shape=[], dtype=tf.float32, default_value=None), 'sum_position': FixedLenFeature(shape=[], dtype=tf.float32, default_value=None), 'sum_attendance': FixedLenFeature(shape=[], dtype=tf.float32, default_value=None), 'average_player_rating': FixedLenFeature(shape=[], dtype=tf.float32, default_value=None), 'team_position': FixedLenFeature(shape=[], dtype=tf.int64, default_value=None), 'sum_player_age': FixedLenFeature(shape=[], dtype=tf.float32, default_value=None), 'average_player_age': FixedLenFeature(shape=[], dtype=tf.float32, default_value=None)}"
     ]
    }
   ],
   "source": [
    "featurestore.get_training_dataset_tf_record_schema(\n",
    "    \"team_position_prediction\", \n",
    "    training_dataset_version=1,\n",
    "    featurestore = featurestore.project_featurestore()\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Imports\n",
    "\n",
    "In this example we will use Tensorflow and Keras. However, the feature store is in theory agnostic to which framework or method you use for training the model, it works with PyTorch, spark-mllib etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "from tensorflow import keras\n",
    "from tensorflow.keras import layers\n",
    "import pandas as pd\n",
    "import json\n",
    "from hops import hdfs\n",
    "from hops import experiment\n",
    "from tensorflow.python.keras.callbacks import TensorBoard\n",
    "from hops import tensorboard"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Constants and HyperParameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [],
   "source": [
    "BATCH_SIZE = 10\n",
    "SHUFFLE_BUFFER_SIZE = 10000\n",
    "INPUT_SHAPE = 11"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Parse TFRecords into A TF-Dataset\n",
    "\n",
    "The dataset is stored in `.tfrecords` format, which essentially means it is stored in protobuf format. Moreover, to be able to read and write datasets in the petabyte-scale, the feature store uses distrbuted write/read to HopsFS with Spark, so the dataset is spread out in a large number of files prefixed with `part-r` (if you are unfamiliar with Spark partitions you can read up on Spark [here](https://spark.apache.org/docs/2.1.0/programming-guide.html)). \n",
    "\n",
    "Despite that our dataset is stored in a binary format and stored disributed in HopsFSs the amount of code to read the data into a tensorflow dataset is very little, thanks to \n",
    "\n",
    "- `featurestore.et_training_dataset_path`: gets the path in HopsFS where the tfrecords files are stored \n",
    "- `featurestore.get_training_dataset_tf_record_schema`: gets the tf-record schema to parse the binary data\n",
    "- `tf.gfile.Glob`: Gets a list of file names from a file-pattern"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_tf_dataset():\n",
    "    dataset_dir = featurestore.get_training_dataset_path(\"team_position_prediction\")\n",
    "    input_files = tf.gfile.Glob(dataset_dir + \"/part-r-*\")\n",
    "    dataset = tf.data.TFRecordDataset(input_files)\n",
    "    tf_record_schema = featurestore.get_training_dataset_tf_record_schema(\"team_position_prediction\")\n",
    "    feature_names = [\"team_budget\", \"average_attendance\", \"average_player_age\", \"sum_attendance\", \n",
    "         \"average_player_rating\", \"average_player_worth\", \"sum_player_age\", \"sum_player_rating\", \"sum_player_worth\", \n",
    "         \"sum_position\", \"average_position\"\n",
    "        ]\n",
    "    label_name = \"team_position\"\n",
    "\n",
    "    def decode(example_proto):\n",
    "        example = tf.parse_single_example(example_proto, tf_record_schema)\n",
    "        x = []\n",
    "        for feature_name in feature_names:\n",
    "            x.append(example[feature_name])\n",
    "        y = [tf.cast(example[label_name], tf.float32)]\n",
    "        return x,y\n",
    "\n",
    "    dataset = dataset.map(decode).shuffle(SHUFFLE_BUFFER_SIZE).batch(BATCH_SIZE).repeat(NUM_EPOCHS)\n",
    "    return dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define The Model using Keras and Tensorflow \n",
    "\n",
    "We will use a three-layer neural network for regression on our dataset. In this tutorial we work with so little data that using a larger model does not make sense."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_model(num_neurons = 64, learning_rate = 0.001):\n",
    "    model = tf.keras.Sequential([\n",
    "        layers.Dense(num_neurons, activation='relu', \n",
    "                     input_shape = (INPUT_SHAPE,),\n",
    "                    batch_size=BATCH_SIZE),\n",
    "        layers.Dense(num_neurons, activation='relu'),\n",
    "        layers.Dense(1)])\n",
    "    return model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define Train Function\n",
    "\n",
    "We define the train code in a separate function so that it can be distributed in the cluster across different executors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_fn(num_neurons_per_layer, learning_rate):\n",
    "    dataset = create_tf_dataset()\n",
    "    model = create_model()\n",
    "    model.compile(optimizer=tf.train.AdamOptimizer(learning_rate), loss='mse', metrics=['accuracy'])\n",
    "    tb_callback = TensorBoard(log_dir=tensorboard.logdir(), histogram_freq=0,\n",
    "                             write_graph=True, write_images=True)\n",
    "    callbacks = [tb_callback]\n",
    "    callbacks.append(keras.callbacks.ModelCheckpoint(tensorboard.logdir() + '/checkpoint-{epoch}.h5',\n",
    "                                                    monitor='acc', verbose=0, save_best_only=True))\n",
    "    history = model.fit(dataset, epochs=NUM_EPOCHS, steps_per_epoch = 5, callbacks=callbacks)\n",
    "    #Return experiment metric (used to direct the search when using hyperparameter search)\n",
    "    return history.history[\"acc\"][-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Hyperparameter Search \n",
    "\n",
    "We will create a reproducible experiment to search for the best hyperparameters for our model using the hops `experiment` module and evolutionary search. \n",
    "\n",
    "When the experiment is running you can view the progress in the SparkUI, from there you can also find the tensorboards for the executors.\n",
    "\n",
    "**Note**: To be able to run this cell you should have started the Jupyter Notebooks Server on Hopsworks with the \"Experiment\" configuration."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generation 0 || average metric: 0.014999999664723873, best metric: 0.019999999552965164, best parameter combination: ['num_neurons_per_layer=113', 'learning_rate=0.005355088982717437']\n",
      "\n",
      "Generation 1 || average metric: 0.019999999552965164, best metric: 0.019999999552965164, best parameter combination: ['num_neurons_per_layer=113', 'learning_rate=0.005355088982717437']\n",
      "\n",
      "Finished Experiment"
     ]
    }
   ],
   "source": [
    "NUM_EPOCHS = 5\n",
    "search_dict = {\"num_neurons_per_layer\" : [64,128], \"learning_rate\": [0.001, 0.01]}\n",
    "log_dir, best_params = experiment.differential_evolution(\n",
    "    train_fn, \n",
    "    search_dict, \n",
    "    name='team_position_prediction_hyperparam_search', \n",
    "    description='Evolutionary search through the search space of hyperparameters with parallel executors to find the best parameters',\n",
    "    local_logdir=True, \n",
    "    population=4,\n",
    "    generations = 1\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Train with the Best Hyperparameters\n",
    "\n",
    "Now we can train for longer amount of epochs when we have found the best hyperparameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'num_neurons_per_layer': '113', 'learning_rate': '0.005355088982717437'}"
     ]
    }
   ],
   "source": [
    "best_params"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [],
   "source": [
    "args_d = {}\n",
    "args_d[\"num_neurons_per_layer\"] = [int(best_params[\"num_neurons_per_layer\"])]\n",
    "args_d[\"learning_rate\"] = [float(best_params[\"learning_rate\"])]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Finished Experiment"
     ]
    }
   ],
   "source": [
    "NUM_EPOCHS = 40\n",
    "experiment_result_path = experiment.launch(\n",
    "    train_fn, \n",
    "    args_dict = args_d,\n",
    "    name='team_position_prediction_hyperparam_search',\n",
    "    description=\"experiment to train model for team position prediction\",\n",
    "    local_logdir=True\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'hdfs://172.31.22.2:8020/Projects/demo_featurestore_admin000/Experiments/application_1573462172517_0010/launcher/run.1'"
     ]
    }
   ],
   "source": [
    "experiment_result_path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "PySpark",
   "language": "",
   "name": "pysparkkernel"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "python",
    "version": 2
   },
   "mimetype": "text/x-python",
   "name": "pyspark",
   "pygments_lexer": "python2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}